KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectstyle > cayenne > graph > GraphManager


1 /* ====================================================================
2  *
3  * The ObjectStyle Group Software License, version 1.1
4  * ObjectStyle Group - http://objectstyle.org/
5  *
6  * Copyright (c) 2002-2005, Andrei (Andrus) Adamchik and individual authors
7  * of the software. All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  * notice, this list of conditions and the following disclaimer in
18  * the documentation and/or other materials provided with the
19  * distribution.
20  *
21  * 3. The end-user documentation included with the redistribution, if any,
22  * must include the following acknowlegement:
23  * "This product includes software developed by independent contributors
24  * and hosted on ObjectStyle Group web site (http://objectstyle.org/)."
25  * Alternately, this acknowlegement may appear in the software itself,
26  * if and wherever such third-party acknowlegements normally appear.
27  *
28  * 4. The names "ObjectStyle Group" and "Cayenne" must not be used to endorse
29  * or promote products derived from this software without prior written
30  * permission. For written permission, email
31  * "andrus at objectstyle dot org".
32  *
33  * 5. Products derived from this software may not be called "ObjectStyle"
34  * or "Cayenne", nor may "ObjectStyle" or "Cayenne" appear in their
35  * names without prior written permission.
36  *
37  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40  * DISCLAIMED. IN NO EVENT SHALL THE OBJECTSTYLE GROUP OR
41  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48  * SUCH DAMAGE.
49  * ====================================================================
50  *
51  * This software consists of voluntary contributions made by many
52  * individuals and hosted on ObjectStyle Group web site. For more
53  * information on the ObjectStyle Group, please see
54  * <http://objectstyle.org/>.
55  */

56 package org.objectstyle.cayenne.graph;
57
58 import java.util.ArrayList JavaDoc;
59 import java.util.Collection JavaDoc;
60 import java.util.HashMap JavaDoc;
61 import java.util.Iterator JavaDoc;
62 import java.util.Map JavaDoc;
63
64 /**
65  * A convenience base implementation of a GraphMap. Performs basic GraphMap operations
66  * (mapping of nodes to their ids) and also provides synchronized API for merging changes
67  * coming via two "channels" - local and remote. GraphManager itself implements
68  * GraphChangeTracker to intercept and preprocess local changes.
69  *
70  * @since 1.2
71  * @author Andrus Adamchik
72  */

73 public class GraphManager implements GraphMap, GraphChangeHandler {
74
75     protected Map JavaDoc nodes;
76
77     protected Collection JavaDoc localChangeHandlers;
78     protected GraphChangeHandler remoteChangeHandler;
79     protected boolean recordingLocalChanges;
80
81     /**
82      * Creates a new GraphManager configured to record local changes.
83      */

84     public GraphManager() {
85         this.nodes = new HashMap JavaDoc();
86         this.recordingLocalChanges = true;
87     }
88
89     /**
90      * Merges a remote change to this graph.
91      */

92     public synchronized void mergeRemoteChange(GraphDiff change) {
93         if (remoteChangeHandler == null) {
94             return;
95         }
96
97         // temporarily block recording of local changes...
98
setRecordingLocalChanges(false);
99
100         try {
101             change.apply(remoteChangeHandler);
102         }
103         finally {
104             setRecordingLocalChanges(true);
105         }
106     }
107
108     public boolean isRecordingLocalChanges() {
109         return recordingLocalChanges;
110     }
111
112     public void setRecordingLocalChanges(boolean active) {
113         this.recordingLocalChanges = active;
114     }
115
116     public synchronized void addLocalChangeHandler(GraphChangeHandler handler) {
117         if (handler != null) {
118             if (localChangeHandlers == null) {
119                 localChangeHandlers = new ArrayList JavaDoc();
120             }
121
122             localChangeHandlers.add(handler);
123         }
124     }
125
126     public synchronized void removeLocalChangeHandler(GraphChangeHandler handler) {
127         if (handler != null && localChangeHandlers != null) {
128             localChangeHandlers.remove(handler);
129
130             if (localChangeHandlers.isEmpty()) {
131                 localChangeHandlers = null;
132             }
133         }
134     }
135
136     public GraphChangeHandler getRemoteChangeHandler() {
137         return remoteChangeHandler;
138     }
139
140     public void setRemoteChangeHandler(GraphChangeHandler handler) {
141         this.remoteChangeHandler = handler;
142     }
143
144     protected Collection JavaDoc getLocalChangeHandlers() {
145         return localChangeHandlers;
146     }
147
148     // *** GraphMap methods
149

150     public synchronized Object JavaDoc getNode(Object JavaDoc nodeId) {
151         return nodes.get(nodeId);
152     }
153
154     public synchronized void registerNode(Object JavaDoc nodeId, Object JavaDoc nodeObject) {
155         nodes.put(nodeId, nodeObject);
156     }
157
158     public synchronized Object JavaDoc unregisterNode(Object JavaDoc nodeId) {
159         return nodes.remove(nodeId);
160     }
161
162     // *** methods for tracking local changes decclared in GraphChangeTracker interface
163

164     public synchronized void arcCreated(Object JavaDoc nodeId, Object JavaDoc targetNodeId, Object JavaDoc arcId) {
165         if (recordingLocalChanges && localChangeHandlers != null) {
166             Iterator JavaDoc it = localChangeHandlers.iterator();
167             while (it.hasNext()) {
168                 ((GraphChangeHandler) it.next()).arcCreated(nodeId, targetNodeId, arcId);
169             }
170         }
171     }
172
173     public synchronized void arcDeleted(Object JavaDoc nodeId, Object JavaDoc targetNodeId, Object JavaDoc arcId) {
174         if (recordingLocalChanges && localChangeHandlers != null) {
175             Iterator JavaDoc it = localChangeHandlers.iterator();
176             while (it.hasNext()) {
177                 ((GraphChangeHandler) it.next()).arcDeleted(nodeId, targetNodeId, arcId);
178             }
179         }
180     }
181
182     public synchronized void nodeCreated(Object JavaDoc nodeId) {
183         if (recordingLocalChanges && localChangeHandlers != null) {
184             Iterator JavaDoc it = localChangeHandlers.iterator();
185             while (it.hasNext()) {
186                 ((GraphChangeHandler) it.next()).nodeCreated(nodeId);
187             }
188         }
189     }
190
191     public synchronized void nodeRemoved(Object JavaDoc nodeId) {
192         if (recordingLocalChanges && localChangeHandlers != null) {
193             Iterator JavaDoc it = localChangeHandlers.iterator();
194             while (it.hasNext()) {
195                 ((GraphChangeHandler) it.next()).nodeRemoved(nodeId);
196             }
197         }
198     }
199
200     public synchronized void nodeIdChanged(Object JavaDoc nodeId, Object JavaDoc newId) {
201         if (recordingLocalChanges && localChangeHandlers != null) {
202             Iterator JavaDoc it = localChangeHandlers.iterator();
203             while (it.hasNext()) {
204                 ((GraphChangeHandler) it.next()).nodeIdChanged(nodeId, newId);
205             }
206         }
207     }
208
209     public synchronized void nodePropertyChanged(
210             Object JavaDoc nodeId,
211             String JavaDoc property,
212             Object JavaDoc oldValue,
213             Object JavaDoc newValue) {
214         if (recordingLocalChanges && localChangeHandlers != null) {
215             Iterator JavaDoc it = localChangeHandlers.iterator();
216             while (it.hasNext()) {
217                 ((GraphChangeHandler) it.next()).nodePropertyChanged(
218                         nodeId,
219                         property,
220                         oldValue,
221                         newValue);
222             }
223         }
224     }
225 }
226
Popular Tags