KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > jofti > tree > NameSpaceTreeOperationAdapter


1 /*
2  * Created on 13-May-2005
3  *
4  */

5 package com.jofti.tree;
6
7 import java.util.ArrayList JavaDoc;
8 import java.util.Collection JavaDoc;
9 import java.util.Iterator JavaDoc;
10 import java.util.LinkedHashSet JavaDoc;
11 import java.util.List JavaDoc;
12 import java.util.Map JavaDoc;
13 import java.util.Set JavaDoc;
14
15 import org.apache.commons.logging.Log;
16 import org.apache.commons.logging.LogFactory;
17
18 import com.jofti.api.NameSpaceKey;
19 import com.jofti.btree.BTOperations;
20 import com.jofti.btree.BTree;
21 import com.jofti.cache.adapter.NameSpaceWrapper;
22 import com.jofti.exception.JoftiException;
23 import com.jofti.introspect.ClassIntrospector;
24 import com.jofti.util.ObjectProcedureAdapter;
25 import com.jofti.util.OpenHashMap;
26
27 /**
28  * The class that the TreeIndex delegates to for operations involving NameSpace caches.<p>
29  *
30  *
31  * @author Steve Woodcock (steve@jofti.com)
32  *
33  */

34 public class NameSpaceTreeOperationAdapter extends TreeOperationAdapter{
35
36
37     public NameSpaceTreeOperationAdapter(){
38     }
39     
40     private static Log log = LogFactory.getLog(NameSpaceTreeOperationAdapter.class);
41     
42     
43   /* (non-Javadoc)
44  * @see com.jofti.tree.TreeOperationAdapter#contains(java.lang.Comparable, com.jofti.btree.BTree, com.jofti.introspect.ClassIntrospector)
45  */

46 public boolean contains(Comparable JavaDoc key,BTree tree, ClassIntrospector parser)throws JoftiException{
47      return BTOperations.contains(tree, key, parser.getKeyDimension(((NameSpaceKey)key).getKey().getClass()));
48    }
49       
50     /* (non-Javadoc)
51      * @see com.jofti.tree.TreeOperationAdapter#insert(java.lang.Comparable, java.lang.Object, com.jofti.btree.BTree, com.jofti.introspect.ClassIntrospector)
52      */

53     public void insert(Comparable JavaDoc key, Object JavaDoc value, BTree tree,ClassIntrospector parser) throws IllegalArgumentException JavaDoc, JoftiException{
54         // first is it the right type
55

56         Map JavaDoc attributes = parser.getAttributeValues(value);
57          if (attributes == null || attributes.isEmpty()){
58              if(log.isDebugEnabled()){
59                     log.debug("No attributes found for '" + key +"' ignoring in index");
60               }
61              return;
62          }
63          
64          List JavaDoc addedObjects = new ArrayList JavaDoc();
65              NameSpaceKey tempKey = (NameSpaceKey)key;
66     
67              // we index the key first
68
if(log.isDebugEnabled()){
69                 log.debug("Attempting to insert name space '" + tempKey +"'");
70              }
71              BTOperations.insertValue(tree, key,new NameSpaceWrapper(tempKey.getNameSpace()),parser.getKeyDimension(NameSpaceWrapper.class));
72
73             // first is it the right type
74

75              try {
76                 
77                  if(log.isDebugEnabled()){
78                     log.debug("Attempting to insert key '" + key +"'");
79                  }
80                   // we index the key first
81
BTOperations.insertKeyValue(tree, key, attributes,parser.getKeyDimension(((NameSpaceKey)key).getClass()));
82                  addedObjects.add(key);
83                  if(log.isDebugEnabled()){
84                     log.debug("inserted key '" + key +"'");
85                  }
86                  
87                  treeInsert(key,tree,attributes,addedObjects);
88                  
89              } catch (JoftiException e){
90                 log.error("Error encountered - removing indexed objects " + addedObjects,e);
91                 removeIndexedValues(key,addedObjects,tree,parser );
92             }
93         
94     }
95      /* (non-Javadoc)
96      * @see com.jofti.tree.TreeOperationAdapter#removeByKey(java.lang.Comparable, com.jofti.btree.BTree, com.jofti.introspect.ClassIntrospector)
97      */

98     public void removeByKey(Comparable JavaDoc value, BTree tree, ClassIntrospector parser) throws JoftiException
99         {
100           
101
102         // Collection matchingValues = BTOperations.getKeyAttributes(tree,value,parser.getKeyDimension(((NameSpaceKey)value).getKey().getClass()));
103
Collection JavaDoc matchingValues = BTOperations.getKeyAttributes(tree,value,parser.getKeyDimension(((NameSpaceKey)value).getClass()));
104             
105             if (matchingValues != null){
106                 if (matchingValues.size() >0){
107                     for (Iterator JavaDoc it = matchingValues.iterator();it.hasNext();){
108                         BTOperations.removeValueObject(tree,value,(Comparable JavaDoc)it.next());
109                         
110                     }
111                 }
112             if(log.isDebugEnabled()){
113                 log.debug("Attempting to remove key '" + value +"'");
114              }
115
116              BTOperations.removeValue(tree, value, value,parser.getKeyDimension(value.getClass()));
117              if(log.isDebugEnabled()){
118                 log.debug("Removed key '" + value +"'");
119              }
120              NameSpaceKey tempKey = (NameSpaceKey)value;
121              if(log.isDebugEnabled()){
122                 log.debug("Attempting to remove name space entry'" + value +"'");
123              }
124              BTOperations.removeValue(tree, value,new NameSpaceWrapper(tempKey.getNameSpace()),parser.getKeyDimension(NameSpaceWrapper.class));
125
126             }
127             
128         }
129       
130     /* (non-Javadoc)
131      * @see com.jofti.tree.TreeOperationAdapter#remove(java.lang.Comparable, java.lang.Object, com.jofti.btree.BTree, com.jofti.introspect.ClassIntrospector)
132      */

133     public void remove(Comparable JavaDoc key, Object JavaDoc value, BTree tree,ClassIntrospector parser) throws IllegalArgumentException JavaDoc, JoftiException{
134         // first is it the right type
135
try{
136             
137             if(log.isDebugEnabled()){
138                 log.debug("Attempting to remove key '" + key +"'");
139              }
140
141              BTOperations.removeValue(tree, key, key,parser.getKeyDimension(((NameSpaceKey)key).getKey().getClass()));
142              if(log.isDebugEnabled()){
143                 log.debug("Removed key '" + key +"'");
144              }
145              
146             treeRemove(key,value,tree,parser);
147
148                 NameSpaceKey tempKey = (NameSpaceKey)key;
149                 // we index the key first
150
if(log.isDebugEnabled()){
151                     log.debug("Attempting to remove name space entry'" + tempKey +"'");
152                  }
153                  BTOperations.removeValue(tree, key,new NameSpaceWrapper(tempKey.getNameSpace()),parser.getKeyDimension(NameSpaceWrapper.class));
154
155          } catch (JoftiException e){
156             throw e;
157          }
158     }
159     
160      /**
161      * @param key
162      * @param added
163      * @param tree
164      * @param parser
165      */

166     private void removeIndexedValues(Object JavaDoc key, List JavaDoc added,BTree tree,ClassIntrospector parser ){
167             removeIndexedValues(key,added,tree);
168         if (key instanceof NameSpaceKey){
169             NameSpaceKey tempKey = (NameSpaceKey)key;
170             // we index the key first
171
if(log.isDebugEnabled()){
172                 log.debug("Attempting to remove name space entry'" + tempKey +"'");
173              }
174              try {
175                 BTOperations.removeValue(tree, new NameSpaceWrapper(tempKey.getNameSpace()),(Comparable JavaDoc)key,parser.getKeyDimension(NameSpaceWrapper.class));
176              } catch (JoftiException e){
177                 log.warn(e);
178              }
179             }
180     }
181     
182      /* (non-Javadoc)
183      * @see com.jofti.tree.TreeOperationAdapter#getAllValuesForKey(java.lang.Comparable, com.jofti.btree.BTree, com.jofti.introspect.ClassIntrospector)
184      */

185     public Map JavaDoc getAllValuesForKey(Comparable JavaDoc key, BTree tree, ClassIntrospector parser)throws JoftiException{
186         
187          return BTOperations.match(tree,key, parser.getKeyDimension(key.getClass()));
188      
189    }
190      
191      /**
192      * @param tree
193      * @param parser
194      * @return A Collection of all the values in that dimension
195      * @throws JoftiException
196      */

197     public Collection JavaDoc getAllValuesForDimension(BTree tree, ClassIntrospector parser)throws JoftiException{
198         final Set JavaDoc tempSet = new LinkedHashSet JavaDoc();
199         Map JavaDoc keyDimensions = parser.getKeyDimensions();
200         
201         
202         for(Iterator JavaDoc it = keyDimensions.entrySet().iterator();it.hasNext();){
203             Map.Entry JavaDoc entry = (Map.Entry JavaDoc) it.next();
204             if (!(entry.getKey() instanceof NameSpaceWrapper)){
205                 OpenHashMap tempMap = (OpenHashMap)BTOperations.getAllResultsForDimension(tree, ((Integer JavaDoc)entry.getValue()).intValue());
206                 tempMap.forEachKey(new ObjectProcedureAdapter(){
207                     public boolean apply(Object JavaDoc key){
208                         tempSet.add(key);
209                         return true;
210                     }
211                 });
212                 //tempSet.addAll(.keySet());
213
}
214             
215         }
216         return tempSet;
217      
218    }
219 }
220
Popular Tags