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 {
51 /** todo check if invalidating already to avoid deadlocks what about concurrency? */
53 private static ObjectStore o_store = ObjectStore.getInstance();
55 private StoreContainerType stocType = null;
56 private StorableObject reference = null;
57 private String uniqueIdentifier = null; // id for Entity & sql for EntityList
58 private long timesUsed;
59 private boolean invalidating = false;
61 protected static LoggerWrapper logger = new LoggerWrapper("Database.ObjectStore");
63 public StoreIdentifier(StorableObject reference, int storeType,
64 String uniqueIdentifier) {
66 if (reference instanceof EntityList)
67 theClass = ( (EntityList) reference).getStorage().getEntityClass();
69 theClass = reference.getClass();
70 this.uniqueIdentifier = uniqueIdentifier;
71 this.stocType = StoreContainerType.valueOf(theClass, storeType);
72 this.reference = reference;
75 public StoreIdentifier(StorableObject reference, String uniqueIdentifier) {
76 this(reference, StoreContainerType.STOC_TYPE_ENTITY, uniqueIdentifier);
79 public StoreIdentifier(Class theClass, String uniqueIdentifier) {
80 this(theClass, StoreContainerType.STOC_TYPE_ENTITY, uniqueIdentifier);
83 public StoreIdentifier(Class theClass, int storeType, String uniqueIdentifier) {
84 this.uniqueIdentifier = uniqueIdentifier;
85 this.stocType = StoreContainerType.valueOf(theClass, storeType);
88 public void invalidate() {
89 logger.info("Invalidating: " + toString());
90 // avoid deadlock due to propagation.
93 if (stocType != null &&
94 stocType.getStocType() == StoreContainerType.STOC_TYPE_ENTITY) {
95 logger.info("Propagating invalidation to EntityList for " + toString());
96 // we should invalidate related ENTITY_LIST
97 StoreContainerType entityListStocType =
98 StoreContainerType.valueOf(stocType.getStocClass(),
99 StoreContainerType.STOC_TYPE_ENTITYLIST);
100 o_store.invalidate(entityListStocType);
103 // propagate invalidation to Set
104 Set set = reference.getNotifyOnReleaseSet();
106 for (Iterator it = set.iterator(); it.hasNext(); ) {
107 Object o = it.next();
108 if (o instanceof StoreIdentifier) {
109 logger.info("Propagating invalidation to StoreIdentifier: " + o.toString());
110 // propagate invalidation to a specific StoreIdentifier in cache
111 o_store.invalidate( (StoreIdentifier) o);
113 else if (o instanceof StoreContainerType) {
114 logger.info("Propagating invalidation to StoreContainer: " + o.toString());
115 // propagate invalidation to a whole StoreContainer
116 o_store.invalidate( (StoreContainerType) o);
125 public void release() {
126 this.reference = null;
127 this.uniqueIdentifier = null;
128 this.stocType = null;
131 public StorableObject use() {
137 * Method equals for comparison between two identifier
139 * @return true if yes otherwise false
142 public boolean equals(Object sid) {
143 if (! (sid instanceof StoreIdentifier))
145 if ( ( (StoreIdentifier) sid).getStoreContainerType() == stocType &&
146 ( (StoreIdentifier) sid).getUniqueIdentifier().equals(uniqueIdentifier)) {
152 public StoreContainerType getStoreContainerType() {
156 public String getUniqueIdentifier() {
157 return uniqueIdentifier;
160 public boolean hasReference() {
161 return (reference == null) ? false : true;
164 public String toString() {
165 StringBuffer id = new StringBuffer(uniqueIdentifier);
166 id.append("@storetype: ").append(stocType.toString());
167 if (reference != null)
168 id.append(" (" + timesUsed).append(") times used.");
169 return id.toString();