2 * Copyright (C) 2001, 2002 The Mir-coders group
4 * This file is part of Mir.
6 * Mir is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * Mir is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with Mir; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * In addition, as a special exception, The Mir-coders gives permission to link
21 * the code of this program with any library licensed under the Apache Software License,
22 * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
23 * (or with modified versions of the above that use the same license as the above),
24 * and distribute linked combinations including the two. You must obey the
25 * GNU General Public License in all respects for all of the code used other than
26 * the above mentioned libraries. If you modify this file, you may extend this
27 * exception to your version of the file, but you are not obligated to do so.
28 * If you do not wish to do so, delete this exception statement from your version.
30 package mir.storage.store;
33 * Title: Class StoreIdentifier
34 * Description: StoreIdentifier has two functions.
35 * A) StoreIdenfier holds a reference to a @see StorableObject
36 * or B) StoreIdentifier is used too search for a @see StorableObject
37 * in the @see StoreContainer that matches its
39 * Copyright: Copyright (c) 2002
44 import java.util.Iterator;
47 import mir.entity.EntityList;
48 import mir.log.LoggerWrapper;
50 public class StoreIdentifier {
52 /** @todo check if invalidating already to avoid deadlocks
53 * what about concurrency? */
55 private static ObjectStore o_store = ObjectStore.getInstance();
57 private StoreContainerType stocType = null;
58 private StorableObject reference = null;
59 private String uniqueIdentifier = null; // id for Entity & sql for EntityList
60 private long timesUsed;
61 private boolean invalidating = false;
63 protected LoggerWrapper logger = new LoggerWrapper("Database.ObjectStore");
65 private StoreIdentifier() {}
67 public StoreIdentifier(StorableObject reference, int storeType,
68 String uniqueIdentifier) {
70 if (reference instanceof EntityList)
71 theClass = ( (EntityList) reference).getStorage().getEntityClass();
73 theClass = reference.getClass();
74 this.uniqueIdentifier = uniqueIdentifier;
75 this.stocType = StoreContainerType.valueOf(theClass, storeType);
76 this.reference = reference;
79 public StoreIdentifier(StorableObject reference, String uniqueIdentifier) {
80 this(reference, StoreContainerType.STOC_TYPE_ENTITY, uniqueIdentifier);
83 public StoreIdentifier(Class theClass, String uniqueIdentifier) {
84 this(theClass, StoreContainerType.STOC_TYPE_ENTITY, uniqueIdentifier);
87 public StoreIdentifier(Class theClass, int storeType, String uniqueIdentifier) {
88 this.uniqueIdentifier = uniqueIdentifier;
89 this.stocType = StoreContainerType.valueOf(theClass, storeType);
92 public void invalidate() {
93 logger.info("Invalidating: " + toString());
94 // avoid deadlock due to propagation.
97 if (stocType != null &&
98 stocType.getStocType() == StoreContainerType.STOC_TYPE_ENTITY) {
99 logger.info("Propagating invalidation to EntityList for " + toString());
100 // we should invalidate related ENTITY_LIST
101 StoreContainerType entityListStocType =
102 StoreContainerType.valueOf(stocType.getStocClass(),
103 StoreContainerType.STOC_TYPE_ENTITYLIST);
104 o_store.invalidate(entityListStocType);
107 // propagate invalidation to Set
108 Set set = reference.getNotifyOnReleaseSet();
110 for (Iterator it = set.iterator(); it.hasNext(); ) {
111 Object o = it.next();
112 if (o instanceof StoreIdentifier) {
113 logger.info("Propagating invalidation to StoreIdentifier: " + o.toString());
114 // propagate invalidation to a specific StoreIdentifier in cache
115 o_store.invalidate( (StoreIdentifier) o);
117 else if (o instanceof StoreContainerType) {
118 logger.info("Propagating invalidation to StoreContainer: " + o.toString());
119 // propagate invalidation to a whole StoreContainer
120 o_store.invalidate( (StoreContainerType) o);
129 public void release() {
130 this.reference = null;
131 this.uniqueIdentifier = null;
132 this.stocType = null;
135 public StorableObject use() {
141 * Method equals for comparison between two identifier
143 * @return true if yes otherwise false
146 public boolean equals(Object sid) {
147 if (! (sid instanceof StoreIdentifier))
149 if ( ( (StoreIdentifier) sid).getStoreContainerType() == stocType &&
150 ( (StoreIdentifier) sid).getUniqueIdentifier().equals(uniqueIdentifier)) {
156 public StoreContainerType getStoreContainerType() {
160 public String getUniqueIdentifier() {
161 return uniqueIdentifier;
164 public boolean hasReference() {
165 return (reference == null) ? false : true;
168 public String toString() {
169 StringBuffer id = new StringBuffer(uniqueIdentifier);
170 id.append("@storetype: ").append(stocType.toString());
171 if (reference != null)
172 id.append(" (" + timesUsed).append(") times used.");
173 return id.toString();