KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > mmbase > module > core > TemporaryNodeManager


1 /*
2
3 This software is OSI Certified Open Source Software.
4 OSI Certified is a certification mark of the Open Source Initiative.
5
6 The license (Mozilla version 1.0) can be read at the MMBase site.
7 See http://www.MMBase.org/license
8
9 */

10 package org.mmbase.module.core;
11
12 import org.mmbase.bridge.Field;
13 import org.mmbase.module.corebuilders.RelDef;
14
15 import org.mmbase.util.logging.Logger;
16 import org.mmbase.util.logging.Logging;
17 import org.mmbase.util.Casting;
18
19 /**
20  * @javadoc
21  *
22  * @author Rico Jansen
23  * @version $Id: TemporaryNodeManager.java,v 1.49 2006/07/06 11:24:44 michiel Exp $
24  */

25 public class TemporaryNodeManager implements TemporaryNodeManagerInterface {
26
27     private static final Logger log = Logging.getLoggerInstance(TemporaryNodeManager.class);
28
29     /**
30      * Return value for setObjectField
31      */

32     public static final String JavaDoc UNKNOWN = "unknown";
33     /**
34      * @since MMBase-1.8
35      */

36     public static final String JavaDoc INVALID_VALUE = "invalid value";
37
38     private final MMBase mmbase;
39
40     /**
41      * @javadoc
42      */

43     public TemporaryNodeManager(MMBase mmbase) {
44         this.mmbase = mmbase;
45     }
46
47     /**
48      * @javadoc
49      */

50     public String JavaDoc createTmpNode(String JavaDoc type, String JavaDoc owner, String JavaDoc key) {
51         if (log.isDebugEnabled()) {
52             log.debug("createTmpNode : type=" + type + " owner=" + owner + " key=" + key);
53         }
54         // WTF!?
55
// if (owner.length() > 12) owner = owner.substring(0, 12);
56
MMObjectBuilder builder = mmbase.getBuilder(type);
57         MMObjectNode node;
58         if (builder != null) {
59             node = builder.getNewTmpNode(owner, getTmpKey(owner, key));
60             if (log.isDebugEnabled()) {
61                 log.debug("New tmpnode " + node);
62             }
63         } else {
64             log.error("Can't find builder " + type);
65         }
66         return key;
67     }
68
69     /**
70      * @javadoc
71      */

72     public String JavaDoc createTmpRelationNode(String JavaDoc role,String JavaDoc owner,String JavaDoc key, String JavaDoc source,String JavaDoc destination) throws Exception JavaDoc {
73         // decode type to a builder using reldef
74
RelDef reldef = mmbase.getRelDef();
75         int rnumber = reldef.getNumberByName(role, true);
76         if(rnumber == -1) {
77             throw new Exception JavaDoc("role " + role + " is not a proper relation");
78         }
79         MMObjectBuilder builder = reldef.getBuilder(reldef.getNode(rnumber));
80         String JavaDoc bulname = builder.getTableName();
81
82         // Create node
83
createTmpNode(bulname, owner, key);
84         setObjectField(owner, key, "_snumber", getTmpKey(owner, source));
85         setObjectField(owner, key, "_dnumber", getTmpKey(owner, destination));
86         setObjectField(owner, key, "rnumber", "" + rnumber);
87         return key;
88     }
89
90     /**
91      * @javadoc
92      */

93     public String JavaDoc createTmpAlias(String JavaDoc name,String JavaDoc owner,String JavaDoc key, String JavaDoc destination) {
94         MMObjectBuilder builder = mmbase.getOAlias();
95         String JavaDoc bulname = builder.getTableName();
96
97         // Create alias node
98
createTmpNode(bulname, owner, key);
99         setObjectField(owner, key, "_destination", getTmpKey(owner, destination));
100         setObjectField(owner, key, "name", name);
101         return key;
102     }
103
104     /**
105      * @javadoc
106      */

107     public String JavaDoc deleteTmpNode(String JavaDoc owner,String JavaDoc key) {
108         MMObjectBuilder b = mmbase.getBuilder("object");
109         b.removeTmpNode(getTmpKey(owner, key));
110         if (log.isDebugEnabled()) {
111             log.debug("delete node " + getTmpKey(owner, key));
112         }
113         return key;
114     }
115
116     /**
117      * @javadoc
118      */

119     public MMObjectNode getNode(String JavaDoc owner, String JavaDoc key) {
120         MMObjectBuilder bul = mmbase.getBuilder("object");
121         MMObjectNode node = bul.getTmpNode(getTmpKey(owner, key));
122         // fallback to normal nodes
123
if (node == null) {
124             log.debug("getNode tmp not node found " + key);
125             node = bul.getNode(key);
126             if(node == null) throw new RuntimeException JavaDoc("Node not found !! (key = '" + key + "')");
127         }
128         return node;
129     }
130
131     /**
132      * @javadoc
133      */

134     public String JavaDoc getObject(String JavaDoc owner, String JavaDoc key, String JavaDoc dbkey) {
135         MMObjectBuilder bul = mmbase.getBuilder("object");
136         MMObjectNode node = bul.getTmpNode(getTmpKey(owner, key));
137         if (node == null) {
138             log.debug("getObject not tmp node found " + key);
139             node = bul.getHardNode(dbkey);
140             if (node == null) {
141                 log.warn("Node not found in database " + dbkey);
142             } else {
143                 bul.putTmpNode(getTmpKey(owner, key), node);
144             }
145         }
146         if (node != null) {
147             return key;
148         } else {
149             return null;
150         }
151     }
152
153     /**
154      * @javadoc
155      * @return An empty string if succesfull, the string {@link #UNKNOWN} if the field was not found in the node.
156      * The string {@link #INVALID_VALUE} if the value was not valid for the field's type.
157      */

158     public String JavaDoc setObjectField(String JavaDoc owner, String JavaDoc key, String JavaDoc field, Object JavaDoc value) {
159         MMObjectNode node = getNode(owner, key);
160         if (node != null) {
161             int type = node.getDBType(field);
162             if (type >= 0) {
163                 if (value instanceof String JavaDoc) {
164                     String JavaDoc stringValue = (String JavaDoc)value;
165                     switch(type) {
166                     case Field.TYPE_XML:
167                     case Field.TYPE_STRING:
168                         node.setValue(field, stringValue);
169                         break;
170                     case Field.TYPE_NODE:
171                     case Field.TYPE_INTEGER:
172                         try {
173                             int i = -1;
174                             if (!stringValue.equals("")) i = Integer.parseInt(stringValue);
175                             node.setValue(field, i);
176                         } catch (NumberFormatException JavaDoc x) {
177                             log.debug("Value for field " + field + " is not a number '" + stringValue + "'");
178                             return INVALID_VALUE;
179                         }
180                         break;
181                     case Field.TYPE_BINARY:
182                         log.error("We don't support casts from String to Binary");
183                         return INVALID_VALUE; // so, a String value is invalid for binaries.
184
case Field.TYPE_FLOAT:
185                         try {
186                             float f = -1;
187                             if (!stringValue.equals("")) f = Float.parseFloat(stringValue);
188                             node.setValue(field,f);
189                         } catch (NumberFormatException JavaDoc x) {
190                             log.debug("Value for field " + field + " is not a number " + stringValue);
191                             return INVALID_VALUE;
192                         }
193                         break;
194                     case Field.TYPE_DOUBLE:
195                         try {
196                             double d = -1;
197                             if (!stringValue.equals("")) d = Double.parseDouble(stringValue);
198                             node.setValue(field,d);
199                         } catch (NumberFormatException JavaDoc x) {
200                             log.debug("Value for field " + field + " is not a number " + stringValue);
201                             return INVALID_VALUE;
202                         }
203                         break;
204                     case Field.TYPE_LONG:
205                         try {
206                             long l = -1;
207                             if (!stringValue.equals("")) l = Long.parseLong(stringValue);
208                             node.setValue(field,l);
209                         } catch (NumberFormatException JavaDoc x) {
210                             log.debug("Value for field " + field + " is not a number " + stringValue);
211                             return INVALID_VALUE;
212                         }
213                         break;
214                     case Field.TYPE_DATETIME:
215                         try {
216                             node.setValue(field, Casting.toDate(value));
217                         } catch (Exception JavaDoc e) {
218                             return INVALID_VALUE;
219                         }
220                         break;
221                     case Field.TYPE_BOOLEAN:
222                         if (org.mmbase.datatypes.StringDataType.BOOLEAN_PATTERN.matcher(stringValue).matches()) {
223                             node.setValue(field, Casting.toBoolean(value));
224                         } else {
225                             return INVALID_VALUE;
226                         }
227                         break;
228                     default:
229                         log.error("Unknown type for field " + field);
230                         break;
231                     }
232                 } else {
233                     node.setValue(field, value);
234                 }
235             } else {
236                 node.setValue(field, value);
237                 log.warn("Invalid type for field " + field);
238                 return UNKNOWN;
239             }
240         } else {
241             log.error("setObjectField(): Can't find node : "+key);
242         }
243         return "";
244     }
245
246     /**
247      * @javadoc
248      * @deprecated use {@link #getObjectField}
249      */

250     public String JavaDoc getObjectFieldAsString(String JavaDoc owner,String JavaDoc key,String JavaDoc field) {
251         String JavaDoc rtn;
252         MMObjectNode node = getNode(owner,key);
253         if (node == null) {
254             log.error("getObjectFieldAsString(): node " + key + " not found!");
255             rtn = "";
256         } else {
257             rtn = node.getStringValue(field);
258         }
259         return rtn;
260     }
261
262     /**
263      * @javadoc
264      */

265     public Object JavaDoc getObjectField(String JavaDoc owner,String JavaDoc key,String JavaDoc field) {
266         Object JavaDoc rtn;
267         MMObjectNode node = getNode(owner,key);
268         if (node == null) {
269             log.error("getObjectFieldAsString(): node " + key + " not found!");
270             rtn = "";
271         } else {
272             rtn = node.getStringValue(field);
273         }
274         return rtn;
275     }
276
277     /**
278      * @javadoc
279      */

280     private String JavaDoc getTmpKey(String JavaDoc owner,String JavaDoc key) {
281         return owner + "_" + key;
282     }
283 }
284
Popular Tags