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