1 karl 1.5 //%2005////////////////////////////////////////////////////////////////////////
|
2 chuck 1.3 //
|
3 karl 1.5 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 chuck 1.3 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.5 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
9 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 chuck 1.3 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
13 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
16 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
18 //
19 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
20 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
22 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Authors: David Rosckes (rosckes@us.ibm.com)
31 // Bert Rivero (hurivero@us.ibm.com)
32 chuck 1.3 // Chuck Carmack (carmack@us.ibm.com)
33 // Brian Lucier (lucier@us.ibm.com)
34 //
35 // Modified By:
36 //
37 //%/////////////////////////////////////////////////////////////////////////////
38
|
39 humberto 1.1 #include "CQLFactory.h"
|
40 humberto 1.4 #include <Pegasus/Common/Tracer.h>
|
41 humberto 1.1
42 PEGASUS_NAMESPACE_BEGIN
43
|
44 chuck 1.3 CQLOBJECTPTR _CQLObjectPtr;
45
46 /*
47 #define PEGASUS_ARRAY_T CQLObjectPtr
48 #include <Pegasus/Common/ArrayImpl.h>
49 #undef PEGASUS_ARRAY_T
50 */
51
52 /*
53 CQLFactory::CQLFactory(){
54
55 }
56 */
57 CQLFactory::~CQLFactory(){
58 cleanup();
59 }
60
61 void CQLFactory::cleanup(){
|
62 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::cleanup");
|
63 chuck 1.3 cleanupArray(_makeObjectIdentifiers, Identifier);
64 cleanupArray(_makeObjectChainedIdentifiers, ChainedIdentifier);
65 cleanupArray(_makeObjectValues, Value);
66 cleanupArray(_makeObjectFunctions, Function);
67 cleanupArray(_makeObjectFactors, Factor);
68 cleanupArray(_makeObjectTerms, Term);
69 cleanupArray(_makeObjectExpressions, Expression);
70 cleanupArray(_makeObjectSimplePredicates, SimplePredicate);
71 cleanupArray(_makeObjectPredicates, Predicate);
72 cleanupArray(_getObjectIdentifiers, Identifier);
73 cleanupArray(_getObjectChainedIdentifiers, ChainedIdentifier);
74 cleanupArray(_getObjectValues, Value);
75 cleanupArray(_getObjectFunctions, Function);
76 cleanupArray(_getObjectFactors, Factor);
77 cleanupArray(_getObjectTerms, Term);
78 cleanupArray(_getObjectExpressions, Expression);
79 cleanupArray(_getObjectSimplePredicates, SimplePredicate);
80 cleanupArray(_getObjectPredicates, Predicate);
|
81 humberto 1.4 PEG_METHOD_EXIT();
|
82 chuck 1.3 }
83 void CQLFactory::cleanupArray(Array<CQLObjectPtr>& arr, FactoryType type){
84 for(Uint32 i=0;i < arr.size(); i++){
85 if(arr[i]._ptr){
86 switch(type){
87 case Predicate:
88 delete (CQLPredicate*)(arr[i]._ptr);
89 break;
90 case SimplePredicate:
91 delete (CQLSimplePredicate*)(arr[i]._ptr);
92 break;
93 case Expression:
94 delete (CQLExpression*)(arr[i]._ptr);
95 break;
96 case Term:
97 delete (CQLTerm*)(arr[i]._ptr);
98 break;
99 case Factor:
100 delete (CQLFactor*)(arr[i]._ptr);
101 break;
102 case Function:
103 chuck 1.3 delete (CQLFunction*)(arr[i]._ptr);
104 break;
105 case Value:
106 delete (CQLValue*)(arr[i]._ptr);
107 break;
108 case ChainedIdentifier:
109 delete (CQLChainedIdentifier*)(arr[i]._ptr);
110 break;
111 case Identifier:
112 delete (CQLIdentifier*)(arr[i]._ptr);
113 break;
114 }
115 }
116 }
117 }
118
|
119 humberto 1.1 void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){
|
120 chuck 1.3 //printf("CQLFactory::makeObject(identifier)\n");
|
121 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLIdentifier");
|
122 chuck 1.3 _CQLObjectPtr._ptr = new CQLChainedIdentifier(*obj);
123 _makeObjectChainedIdentifiers.append(_CQLObjectPtr);
|
124 humberto 1.1 switch(target){
125 case ChainedIdentifier:
|
126 chuck 1.3 return _makeObjectChainedIdentifiers[_makeObjectChainedIdentifiers.size()-1]._ptr;
|
127 humberto 1.1 break;
128 case Identifier:
129 return NULL;
130 break;
131 default:
|
132 chuck 1.3 return makeObject((CQLChainedIdentifier*)(_CQLObjectPtr._ptr), target);
|
133 humberto 1.1 break;
134 }
|
135 humberto 1.4 PEG_METHOD_EXIT();
|
136 humberto 1.1 }
137 void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target){
|
138 chuck 1.3 //printf("CQLFactory::makeObject(chainedidentifier)\n");
|
139 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLChainedIdentifier");
|
140 chuck 1.3 _CQLObjectPtr._ptr = new CQLValue(*obj);
141 CQLValue* _val = (CQLValue*)_CQLObjectPtr._ptr;
142 _makeObjectValues.append(_CQLObjectPtr);
|
143 humberto 1.1 switch(target){
144 case Value:
|
145 chuck 1.3 return _makeObjectValues[_makeObjectValues.size()-1]._ptr;
|
146 humberto 1.1 break;
147 case ChainedIdentifier:
148 return NULL;
149 break;
150 default:
|
151 chuck 1.3 return makeObject((CQLValue*)(_CQLObjectPtr._ptr), target);
|
152 humberto 1.1 break;
153 }
|
154 humberto 1.4 PEG_METHOD_EXIT();
|
155 humberto 1.1 }
156 void* CQLFactory::makeObject(CQLValue* obj, FactoryType target){
|
157 chuck 1.3 //printf("CQLFactory::makeObject(value)\n");
|
158 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLValue");
|
159 chuck 1.3 _CQLObjectPtr._ptr = new CQLFactor(*obj);
160 _makeObjectFactors.append(_CQLObjectPtr);
|
161 humberto 1.1 switch(target){
162 case Factor:
|
163 chuck 1.3 return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
|
164 humberto 1.1 break;
165 case Value:
166 return NULL;
167 break;
168 default:
|
169 chuck 1.3 return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
|
170 humberto 1.1 break;
171 }
|
172 humberto 1.4 PEG_METHOD_EXIT();
|
173 humberto 1.1 }
|
174 chuck 1.3 void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target){
175 //printf("CQLFactory::makeObject(function)\n");
|
176 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFunction");
|
177 chuck 1.3 _CQLObjectPtr._ptr = new CQLFactor(*obj);
178 _makeObjectFactors.append(_CQLObjectPtr);
179 switch(target){
180 case Factor:
181 return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
182 break;
183 default:
184 return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
185 break;
186 }
|
187 humberto 1.4 PEG_METHOD_EXIT();
|
188 chuck 1.3 }
|
189 humberto 1.1 void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){
|
190 chuck 1.3 //printf("CQLFactory::makeObject(factor)\n");
|
191 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFactor");
|
192 chuck 1.3 _CQLObjectPtr._ptr = new CQLTerm(*obj);
193 _makeObjectTerms.append(_CQLObjectPtr);
|
194 humberto 1.1 switch(target){
195 case Term:
|
196 chuck 1.3 return _makeObjectTerms[_makeObjectTerms.size()-1]._ptr;
|
197 humberto 1.1 break;
198 case Factor:
199 return NULL;
200 break;
201 default:
|
202 chuck 1.3 return makeObject((CQLTerm*)(_CQLObjectPtr._ptr), target);
|
203 humberto 1.1 break;
204 }
|
205 carson.hovey 1.7 PEG_METHOD_EXIT();
|
206 humberto 1.1 }
207 void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target){
|
208 chuck 1.3 //printf("CQLFactory::makeObject(term)\n");
|
209 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLTerm");
|
210 chuck 1.3 _CQLObjectPtr._ptr = new CQLExpression(*obj);
211 _makeObjectExpressions.append(_CQLObjectPtr);
|
212 humberto 1.1 switch(target){
213 case Expression:
|
214 chuck 1.3 return _makeObjectExpressions[_makeObjectExpressions.size()-1]._ptr;
|
215 humberto 1.1 break;
216 case Term:
217 return NULL;
218 break;
219 default:
|
220 chuck 1.3 return makeObject((CQLExpression*)(_CQLObjectPtr._ptr), target);
|
221 humberto 1.1 break;
222 }
|
223 humberto 1.4 PEG_METHOD_EXIT();
|
224 humberto 1.1 }
225 void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target){
|
226 chuck 1.3 //printf("CQLFactory::makeObject(expression)\n");
|
227 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLExpression");
|
228 chuck 1.3 _CQLObjectPtr._ptr = new CQLSimplePredicate(*obj);
229 _makeObjectSimplePredicates.append(_CQLObjectPtr);
|
230 humberto 1.1 switch(target){
231 case SimplePredicate:
|
232 chuck 1.3 return _makeObjectSimplePredicates[_makeObjectSimplePredicates.size()-1]._ptr;
|
233 humberto 1.1 break;
234 case Expression:
235 return NULL;
236 break;
237 default:
|
238 chuck 1.3 return makeObject((CQLSimplePredicate*)(_CQLObjectPtr._ptr), target);
|
239 humberto 1.1 break;
240 }
|
241 humberto 1.4 PEG_METHOD_EXIT();
|
242 humberto 1.1 }
243 void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target){
|
244 chuck 1.3 //printf("CQLFactory::makeObject(simplepredicate)\n");
|
245 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLSimplePredicate");
|
246 chuck 1.3 _CQLObjectPtr._ptr = new CQLPredicate(*obj);
247 _makeObjectPredicates.append(_CQLObjectPtr);
|
248 humberto 1.1 switch(target){
249 case Predicate:
|
250 chuck 1.3 return _makeObjectPredicates[_makeObjectPredicates.size()-1]._ptr;
251 break;
252 default:
253 return NULL;
254 break;
255 }
|
256 humberto 1.4 PEG_METHOD_EXIT();
|
257 chuck 1.3 }
258
259 void* CQLFactory::getObject(void* inObject, FactoryType inObjectType, FactoryType targetType){
|
260 carson.hovey 1.8
|
261 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::getObject");
|
262 carson.hovey 1.8
263 void * obj = NULL;
264
|
265 chuck 1.3 switch(inObjectType){
266 case Predicate:
|
267 carson.hovey 1.8 obj = getObject(((CQLPredicate*)inObject),targetType);
268 break;
|
269 chuck 1.3 case SimplePredicate:
|
270 carson.hovey 1.8 obj = getObject(((CQLSimplePredicate*)inObject),targetType);
271 break;
|
272 chuck 1.3 case Expression:
|
273 carson.hovey 1.8 obj = getObject(((CQLExpression*)inObject),targetType);
274 break;
|
275 chuck 1.3 case Term:
|
276 carson.hovey 1.8 obj = getObject(((CQLTerm*)inObject),targetType);
277 break;
|
278 chuck 1.3 case Factor:
|
279 carson.hovey 1.8 obj = getObject(((CQLFactor*)inObject),targetType);
280 break;
|
281 chuck 1.3 case Function:
|
282 carson.hovey 1.8 obj = NULL;
283 break;
|
284 chuck 1.3 case Value:
|
285 carson.hovey 1.8 obj = getObject(((CQLValue*)inObject),targetType);
286 break;
|
287 chuck 1.3 case ChainedIdentifier:
|
288 carson.hovey 1.8 obj = getObject(((CQLChainedIdentifier*)inObject),targetType);
289 break;
|
290 chuck 1.3 default:
|
291 carson.hovey 1.8 obj = NULL;
292 break;
|
293 chuck 1.3 }
|
294 carson.hovey 1.8
295 PEG_METHOD_EXIT();
296 return obj;
|
297 chuck 1.3 }
298
299 void* CQLFactory::getObject(CQLChainedIdentifier* obj, FactoryType target){
300 // printf("CQLFactory::getObject(CQLChainedIdentifier* obj)\n");
301 Array<CQLIdentifier> cqlIds;
302
303 switch(target){
304 case Identifier:
305 //if(obj->_rep->_subIdentifiers.size() > 0){
306 cqlIds = obj->getSubIdentifiers();
307 if(cqlIds.size() > 0){
308
309 // _CQLObjectPtr._ptr = new CQLIdentifier(obj->_rep->_subIdentifiers[0]);
310 _CQLObjectPtr._ptr = new CQLIdentifier(cqlIds[0]);
311 _getObjectIdentifiers.append(_CQLObjectPtr);
312 return _getObjectIdentifiers[_getObjectIdentifiers.size()-1]._ptr;
313 }
314 return NULL;
315 default:
316 return NULL;
317 }
318 chuck 1.3 }
319
320 void* CQLFactory::getObject(CQLValue* obj, FactoryType target){
321 // printf("CQLFactory::getObject(CQLValue* obj)\n");
322 switch(target){
323 case ChainedIdentifier:
324 _CQLObjectPtr._ptr = new CQLChainedIdentifier(obj->_rep->_CQLChainId);
325 _getObjectChainedIdentifiers.append(_CQLObjectPtr);
326 return _getObjectChainedIdentifiers[_getObjectChainedIdentifiers.size()-1]._ptr;
327 case Identifier:
328 return getObject(&(obj->_rep->_CQLChainId),target);
329 default:
330 return NULL;
331 break;
332 }
333 }
334
335 void* CQLFactory::getObject(CQLFactor* obj, FactoryType target){
336 // printf("CQLFactory::getObject(CQLFactor* obj)\n");
337 switch(target){
338 case Function:
339 chuck 1.3 _CQLObjectPtr._ptr = new CQLFunction(obj->_rep->_CQLFunct);
340 _getObjectFunctions.append(_CQLObjectPtr);
341 return _getObjectFunctions[_getObjectFunctions.size()-1]._ptr;
342 case Value:
343 _CQLObjectPtr._ptr = new CQLValue(obj->_rep->_CQLVal);
344 _getObjectValues.append(_CQLObjectPtr);
345 return _getObjectValues[_getObjectValues.size()-1]._ptr;
346 case ChainedIdentifier:
347 case Identifier:
348 return getObject(&(obj->_rep->_CQLVal),target);
349 default:
350 return NULL;
|
351 humberto 1.1 break;
|
352 chuck 1.3 }
353 }
354
355
356 void* CQLFactory::getObject(CQLTerm* obj, FactoryType target){
357 // printf("CQLFactory::getObject(CQLTerm* obj)\n");
358 switch(target){
359 case Factor:
360 _CQLObjectPtr._ptr = new CQLFactor(obj->getFactors()[0]);
361 _getObjectFactors.append(_CQLObjectPtr);
362 return _getObjectFactors[_getObjectFactors.size()-1]._ptr;
363 case Function:
364 case Value:
365 case ChainedIdentifier:
366 case Identifier:
367 return getObject(&(obj->getFactors()[0]),target);
|
368 humberto 1.1 default:
369 return NULL;
370 break;
371 }
|
372 chuck 1.3 }
|
373 humberto 1.1
|
374 chuck 1.3 void* CQLFactory::getObject(CQLExpression* obj, FactoryType target){
375 // printf("CQLFactory::getObject(CQLExpression* obj)\n");
376 switch(target){
377 case Term:
378 _CQLObjectPtr._ptr = new CQLTerm(obj->getTerms()[0]);
379 _getObjectTerms.append(_CQLObjectPtr);
380 return _getObjectTerms[_getObjectTerms.size()-1]._ptr;
381 case Factor:
382 case Function:
383 case Value:
384 case ChainedIdentifier:
385 case Identifier:
386 return getObject(&(obj->getTerms()[0]), target);
387 default:
388 return NULL;
389 break;
390 }
|
391 humberto 1.1 }
392
|
393 chuck 1.3 void* CQLFactory::getObject(CQLSimplePredicate* obj, FactoryType target){
394 // printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");
395 switch(target){
396 case Expression:
397 _CQLObjectPtr._ptr = new CQLExpression(obj->_rep->_leftSide);
398 _getObjectExpressions.append(_CQLObjectPtr);
399 return _getObjectExpressions[_getObjectExpressions.size()-1]._ptr;
400 case Term:
401 case Factor:
402 case Function:
403 case Value:
404 case ChainedIdentifier:
405 case Identifier:
406 return getObject(&(obj->_rep->_leftSide), target);
407 default:
408 return NULL;
409 break;
410 }
411 }
|
412 humberto 1.1
|
413 chuck 1.3 void* CQLFactory::getObject(CQLPredicate* obj, FactoryType target){
414 // printf("CQLFactory::getObject(CQLPredicate* obj)\n");
415 switch(target){
416 case SimplePredicate:
417 _CQLObjectPtr._ptr = new CQLSimplePredicate(obj->_rep->_simplePredicate);
418 _getObjectSimplePredicates.append(_CQLObjectPtr);
419 return _getObjectSimplePredicates[_getObjectSimplePredicates.size()-1]._ptr;
420 case Expression:
421 case Term:
422 case Factor:
423 case Function:
424 case Value:
425 case ChainedIdentifier:
426 case Identifier:
427 return getObject(&(obj->_rep->_simplePredicate), target);
428 default:
429 return NULL;
430 break;
431 }
432 }
433
434 chuck 1.3 void CQLFactory::setObject(CQLPredicate* predicate, void* obj, FactoryType objType){
|
435 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::setObject");
|
436 chuck 1.3 switch(objType){
437 case SimplePredicate:
438 predicate->_rep->_simplePredicate = *((CQLSimplePredicate*)obj);
439 break;
440 case Expression:
441 predicate->_rep->_simplePredicate._rep->_leftSide = *((CQLExpression*)obj);
442 break;
443 case Term:
444 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0] =
445 *((CQLTerm*)obj);
446 break;
447 case Factor:
448 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0] =
449 *((CQLFactor*)obj);
450 break;
451 case Function:
452 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLFunct =
453 *((CQLFunction*)obj);
454 break;
455 case Value:
456 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal =
457 chuck 1.3 *((CQLValue*)obj);
458 break;
459 case ChainedIdentifier:
460 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal._rep->_CQLChainId = *((CQLChainedIdentifier*)obj);
461 break;
462 case Identifier:
463 break;
464 default:
465 break;
466 }
|
467 humberto 1.4 PEG_METHOD_EXIT();
|
468 chuck 1.3 }
|
469 humberto 1.1 PEGASUS_NAMESPACE_END
|
Return to
CQLFactory.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / CQL