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 /** @todo initialize logfile */
67 private StoreIdentifier() {}
69 public StoreIdentifier(StorableObject reference, int storeType,
70 String uniqueIdentifier) {
72 if (reference instanceof EntityList)
73 theClass = ( (EntityList) reference).getStorage().getEntityClass();
75 theClass = reference.getClass();
76 this.uniqueIdentifier = uniqueIdentifier;
77 this.stocType = StoreContainerType.valueOf(theClass, storeType);
78 this.reference = reference;
81 public StoreIdentifier(StorableObject reference, String uniqueIdentifier) {
82 this(reference, StoreContainerType.STOC_TYPE_ENTITY, uniqueIdentifier);
85 public StoreIdentifier(Class theClass, String uniqueIdentifier) {
86 this(theClass, StoreContainerType.STOC_TYPE_ENTITY, uniqueIdentifier);
89 public StoreIdentifier(Class theClass, int storeType, String uniqueIdentifier) {
90 this.uniqueIdentifier = uniqueIdentifier;
91 this.stocType = StoreContainerType.valueOf(theClass, storeType);
100 public void invalidate() {
101 logger.info("Invalidating: " + toString());
102 // avoid deadlock due to propagation.
105 if (stocType != null &&
106 stocType.getStocType() == StoreContainerType.STOC_TYPE_ENTITY) {
107 logger.info("Propagating invalidation to EntityList for " + toString());
108 // we should invalidate related ENTITY_LIST
109 StoreContainerType entityListStocType =
110 StoreContainerType.valueOf(stocType.getStocClass(),
111 StoreContainerType.STOC_TYPE_ENTITYLIST);
112 o_store.invalidate(entityListStocType);
115 // propagate invalidation to Set
116 Set set = reference.getNotifyOnReleaseSet();
118 for (Iterator it = set.iterator(); it.hasNext(); ) {
119 Object o = it.next();
120 if (o instanceof StoreIdentifier) {
121 logger.info("Propagating invalidation to StoreIdentifier: " + o.toString());
122 // propagate invalidation to a specific StoreIdentifier in cache
123 o_store.invalidate( (StoreIdentifier) o);
125 else if (o instanceof StoreContainerType) {
126 logger.info("Propagating invalidation to StoreContainer: " + o.toString());
127 // propagate invalidation to a whole StoreContainer
128 o_store.invalidate( (StoreContainerType) o);
137 public void release() {
138 this.reference = null;
139 this.uniqueIdentifier = null;
140 this.stocType = null;
143 public StorableObject use() {
149 * Method equals for comparison between two identifier
151 * @return true if yes otherwise false
154 public boolean equals(Object sid) {
155 if (! (sid instanceof StoreIdentifier))
157 if ( ( (StoreIdentifier) sid).getStoreContainerType() == stocType &&
158 ( (StoreIdentifier) sid).getUniqueIdentifier().equals(uniqueIdentifier)) {
164 public StoreContainerType getStoreContainerType() {
168 public String getUniqueIdentifier() {
169 return uniqueIdentifier;
172 public boolean hasReference() {
173 return (reference == null) ? false : true;
176 public String toString() {
177 StringBuffer id = new StringBuffer(uniqueIdentifier);
178 id.append("@storetype: ").append(stocType.toString());
179 if (reference != null)
180 id.append(" (" + timesUsed).append(") times used.");
181 return id.toString();