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 david.dillard 1.9 #include "CQLValueRep.h"
41 #include "CQLFactorRep.h"
42 #include "CQLSimplePredicateRep.h"
43 #include "CQLPredicateRep.h"
44 #include "CQLExpressionRep.h"
45 #include "CQLTermRep.h"
|
46 humberto 1.4 #include <Pegasus/Common/Tracer.h>
|
47 humberto 1.1
48 PEGASUS_NAMESPACE_BEGIN
49
|
50 chuck 1.3 CQLOBJECTPTR _CQLObjectPtr;
51
52 /*
53 #define PEGASUS_ARRAY_T CQLObjectPtr
54 #include <Pegasus/Common/ArrayImpl.h>
55 #undef PEGASUS_ARRAY_T
56 */
57
58 /*
59 CQLFactory::CQLFactory(){
60
61 }
62 */
63 CQLFactory::~CQLFactory(){
64 cleanup();
65 }
66
67 void CQLFactory::cleanup(){
|
68 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::cleanup");
|
69 chuck 1.3 cleanupArray(_makeObjectIdentifiers, Identifier);
70 cleanupArray(_makeObjectChainedIdentifiers, ChainedIdentifier);
71 cleanupArray(_makeObjectValues, Value);
72 cleanupArray(_makeObjectFunctions, Function);
73 cleanupArray(_makeObjectFactors, Factor);
74 cleanupArray(_makeObjectTerms, Term);
75 cleanupArray(_makeObjectExpressions, Expression);
76 cleanupArray(_makeObjectSimplePredicates, SimplePredicate);
77 cleanupArray(_makeObjectPredicates, Predicate);
78 cleanupArray(_getObjectIdentifiers, Identifier);
79 cleanupArray(_getObjectChainedIdentifiers, ChainedIdentifier);
80 cleanupArray(_getObjectValues, Value);
81 cleanupArray(_getObjectFunctions, Function);
82 cleanupArray(_getObjectFactors, Factor);
83 cleanupArray(_getObjectTerms, Term);
84 cleanupArray(_getObjectExpressions, Expression);
85 cleanupArray(_getObjectSimplePredicates, SimplePredicate);
86 cleanupArray(_getObjectPredicates, Predicate);
|
87 humberto 1.4 PEG_METHOD_EXIT();
|
88 chuck 1.3 }
89 void CQLFactory::cleanupArray(Array<CQLObjectPtr>& arr, FactoryType type){
90 for(Uint32 i=0;i < arr.size(); i++){
91 if(arr[i]._ptr){
92 switch(type){
93 case Predicate:
94 delete (CQLPredicate*)(arr[i]._ptr);
95 break;
96 case SimplePredicate:
97 delete (CQLSimplePredicate*)(arr[i]._ptr);
98 break;
99 case Expression:
100 delete (CQLExpression*)(arr[i]._ptr);
101 break;
102 case Term:
103 delete (CQLTerm*)(arr[i]._ptr);
104 break;
105 case Factor:
106 delete (CQLFactor*)(arr[i]._ptr);
107 break;
108 case Function:
109 chuck 1.3 delete (CQLFunction*)(arr[i]._ptr);
110 break;
111 case Value:
112 delete (CQLValue*)(arr[i]._ptr);
113 break;
114 case ChainedIdentifier:
115 delete (CQLChainedIdentifier*)(arr[i]._ptr);
116 break;
117 case Identifier:
118 delete (CQLIdentifier*)(arr[i]._ptr);
119 break;
120 }
121 }
122 }
123 }
124
|
125 humberto 1.1 void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target){
|
126 chuck 1.3 //printf("CQLFactory::makeObject(identifier)\n");
|
127 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLIdentifier");
|
128 chuck 1.3 _CQLObjectPtr._ptr = new CQLChainedIdentifier(*obj);
129 _makeObjectChainedIdentifiers.append(_CQLObjectPtr);
|
130 humberto 1.1 switch(target){
131 case ChainedIdentifier:
|
132 chuck 1.3 return _makeObjectChainedIdentifiers[_makeObjectChainedIdentifiers.size()-1]._ptr;
|
133 humberto 1.1 break;
134 case Identifier:
135 return NULL;
136 break;
137 default:
|
138 chuck 1.3 return makeObject((CQLChainedIdentifier*)(_CQLObjectPtr._ptr), target);
|
139 humberto 1.1 break;
140 }
|
141 humberto 1.4 PEG_METHOD_EXIT();
|
142 humberto 1.1 }
143 void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target){
|
144 chuck 1.3 //printf("CQLFactory::makeObject(chainedidentifier)\n");
|
145 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLChainedIdentifier");
|
146 chuck 1.3 _CQLObjectPtr._ptr = new CQLValue(*obj);
147 CQLValue* _val = (CQLValue*)_CQLObjectPtr._ptr;
148 _makeObjectValues.append(_CQLObjectPtr);
|
149 humberto 1.1 switch(target){
150 case Value:
|
151 chuck 1.3 return _makeObjectValues[_makeObjectValues.size()-1]._ptr;
|
152 humberto 1.1 break;
153 case ChainedIdentifier:
154 return NULL;
155 break;
156 default:
|
157 chuck 1.3 return makeObject((CQLValue*)(_CQLObjectPtr._ptr), target);
|
158 humberto 1.1 break;
159 }
|
160 humberto 1.4 PEG_METHOD_EXIT();
|
161 humberto 1.1 }
162 void* CQLFactory::makeObject(CQLValue* obj, FactoryType target){
|
163 chuck 1.3 //printf("CQLFactory::makeObject(value)\n");
|
164 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLValue");
|
165 chuck 1.3 _CQLObjectPtr._ptr = new CQLFactor(*obj);
166 _makeObjectFactors.append(_CQLObjectPtr);
|
167 humberto 1.1 switch(target){
168 case Factor:
|
169 chuck 1.3 return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
|
170 humberto 1.1 break;
171 case Value:
172 return NULL;
173 break;
174 default:
|
175 chuck 1.3 return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
|
176 humberto 1.1 break;
177 }
|
178 humberto 1.4 PEG_METHOD_EXIT();
|
179 humberto 1.1 }
|
180 chuck 1.3 void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target){
181 //printf("CQLFactory::makeObject(function)\n");
|
182 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFunction");
|
183 chuck 1.3 _CQLObjectPtr._ptr = new CQLFactor(*obj);
184 _makeObjectFactors.append(_CQLObjectPtr);
185 switch(target){
186 case Factor:
187 return _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
188 break;
189 default:
190 return makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
191 break;
192 }
|
193 humberto 1.4 PEG_METHOD_EXIT();
|
194 chuck 1.3 }
|
195 humberto 1.1 void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target){
|
196 chuck 1.3 //printf("CQLFactory::makeObject(factor)\n");
|
197 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFactor");
|
198 chuck 1.3 _CQLObjectPtr._ptr = new CQLTerm(*obj);
199 _makeObjectTerms.append(_CQLObjectPtr);
|
200 humberto 1.1 switch(target){
201 case Term:
|
202 chuck 1.3 return _makeObjectTerms[_makeObjectTerms.size()-1]._ptr;
|
203 humberto 1.1 break;
204 case Factor:
205 return NULL;
206 break;
207 default:
|
208 chuck 1.3 return makeObject((CQLTerm*)(_CQLObjectPtr._ptr), target);
|
209 humberto 1.1 break;
210 }
|
211 carson.hovey 1.7 PEG_METHOD_EXIT();
|
212 humberto 1.1 }
213 void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target){
|
214 chuck 1.3 //printf("CQLFactory::makeObject(term)\n");
|
215 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLTerm");
|
216 chuck 1.3 _CQLObjectPtr._ptr = new CQLExpression(*obj);
217 _makeObjectExpressions.append(_CQLObjectPtr);
|
218 humberto 1.1 switch(target){
219 case Expression:
|
220 chuck 1.3 return _makeObjectExpressions[_makeObjectExpressions.size()-1]._ptr;
|
221 humberto 1.1 break;
222 case Term:
223 return NULL;
224 break;
225 default:
|
226 chuck 1.3 return makeObject((CQLExpression*)(_CQLObjectPtr._ptr), target);
|
227 humberto 1.1 break;
228 }
|
229 humberto 1.4 PEG_METHOD_EXIT();
|
230 humberto 1.1 }
231 void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target){
|
232 chuck 1.3 //printf("CQLFactory::makeObject(expression)\n");
|
233 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLExpression");
|
234 chuck 1.3 _CQLObjectPtr._ptr = new CQLSimplePredicate(*obj);
235 _makeObjectSimplePredicates.append(_CQLObjectPtr);
|
236 humberto 1.1 switch(target){
237 case SimplePredicate:
|
238 chuck 1.3 return _makeObjectSimplePredicates[_makeObjectSimplePredicates.size()-1]._ptr;
|
239 humberto 1.1 break;
240 case Expression:
241 return NULL;
242 break;
243 default:
|
244 chuck 1.3 return makeObject((CQLSimplePredicate*)(_CQLObjectPtr._ptr), target);
|
245 humberto 1.1 break;
246 }
|
247 humberto 1.4 PEG_METHOD_EXIT();
|
248 humberto 1.1 }
249 void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target){
|
250 chuck 1.3 //printf("CQLFactory::makeObject(simplepredicate)\n");
|
251 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLSimplePredicate");
|
252 chuck 1.3 _CQLObjectPtr._ptr = new CQLPredicate(*obj);
253 _makeObjectPredicates.append(_CQLObjectPtr);
|
254 humberto 1.1 switch(target){
255 case Predicate:
|
256 chuck 1.3 return _makeObjectPredicates[_makeObjectPredicates.size()-1]._ptr;
257 break;
258 default:
259 return NULL;
260 break;
261 }
|
262 humberto 1.4 PEG_METHOD_EXIT();
|
263 chuck 1.3 }
264
265 void* CQLFactory::getObject(void* inObject, FactoryType inObjectType, FactoryType targetType){
|
266 carson.hovey 1.8
|
267 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::getObject");
|
268 carson.hovey 1.8
269 void * obj = NULL;
270
|
271 chuck 1.3 switch(inObjectType){
272 case Predicate:
|
273 carson.hovey 1.8 obj = getObject(((CQLPredicate*)inObject),targetType);
274 break;
|
275 chuck 1.3 case SimplePredicate:
|
276 carson.hovey 1.8 obj = getObject(((CQLSimplePredicate*)inObject),targetType);
277 break;
|
278 chuck 1.3 case Expression:
|
279 carson.hovey 1.8 obj = getObject(((CQLExpression*)inObject),targetType);
280 break;
|
281 chuck 1.3 case Term:
|
282 carson.hovey 1.8 obj = getObject(((CQLTerm*)inObject),targetType);
283 break;
|
284 chuck 1.3 case Factor:
|
285 carson.hovey 1.8 obj = getObject(((CQLFactor*)inObject),targetType);
286 break;
|
287 chuck 1.3 case Function:
|
288 carson.hovey 1.8 obj = NULL;
289 break;
|
290 chuck 1.3 case Value:
|
291 carson.hovey 1.8 obj = getObject(((CQLValue*)inObject),targetType);
292 break;
|
293 chuck 1.3 case ChainedIdentifier:
|
294 carson.hovey 1.8 obj = getObject(((CQLChainedIdentifier*)inObject),targetType);
295 break;
|
296 chuck 1.3 default:
|
297 carson.hovey 1.8 obj = NULL;
298 break;
|
299 chuck 1.3 }
|
300 carson.hovey 1.8
301 PEG_METHOD_EXIT();
302 return obj;
|
303 chuck 1.3 }
304
305 void* CQLFactory::getObject(CQLChainedIdentifier* obj, FactoryType target){
306 // printf("CQLFactory::getObject(CQLChainedIdentifier* obj)\n");
307 Array<CQLIdentifier> cqlIds;
308
309 switch(target){
310 case Identifier:
311 //if(obj->_rep->_subIdentifiers.size() > 0){
312 cqlIds = obj->getSubIdentifiers();
313 if(cqlIds.size() > 0){
314
315 // _CQLObjectPtr._ptr = new CQLIdentifier(obj->_rep->_subIdentifiers[0]);
316 _CQLObjectPtr._ptr = new CQLIdentifier(cqlIds[0]);
317 _getObjectIdentifiers.append(_CQLObjectPtr);
318 return _getObjectIdentifiers[_getObjectIdentifiers.size()-1]._ptr;
319 }
320 return NULL;
321 default:
322 return NULL;
323 }
324 chuck 1.3 }
325
326 void* CQLFactory::getObject(CQLValue* obj, FactoryType target){
327 // printf("CQLFactory::getObject(CQLValue* obj)\n");
328 switch(target){
329 case ChainedIdentifier:
330 _CQLObjectPtr._ptr = new CQLChainedIdentifier(obj->_rep->_CQLChainId);
331 _getObjectChainedIdentifiers.append(_CQLObjectPtr);
332 return _getObjectChainedIdentifiers[_getObjectChainedIdentifiers.size()-1]._ptr;
333 case Identifier:
334 return getObject(&(obj->_rep->_CQLChainId),target);
335 default:
336 return NULL;
337 break;
338 }
339 }
340
341 void* CQLFactory::getObject(CQLFactor* obj, FactoryType target){
342 // printf("CQLFactory::getObject(CQLFactor* obj)\n");
343 switch(target){
344 case Function:
345 chuck 1.3 _CQLObjectPtr._ptr = new CQLFunction(obj->_rep->_CQLFunct);
346 _getObjectFunctions.append(_CQLObjectPtr);
347 return _getObjectFunctions[_getObjectFunctions.size()-1]._ptr;
348 case Value:
349 _CQLObjectPtr._ptr = new CQLValue(obj->_rep->_CQLVal);
350 _getObjectValues.append(_CQLObjectPtr);
351 return _getObjectValues[_getObjectValues.size()-1]._ptr;
352 case ChainedIdentifier:
353 case Identifier:
354 return getObject(&(obj->_rep->_CQLVal),target);
355 default:
356 return NULL;
|
357 humberto 1.1 break;
|
358 chuck 1.3 }
359 }
360
361
362 void* CQLFactory::getObject(CQLTerm* obj, FactoryType target){
363 // printf("CQLFactory::getObject(CQLTerm* obj)\n");
364 switch(target){
365 case Factor:
366 _CQLObjectPtr._ptr = new CQLFactor(obj->getFactors()[0]);
367 _getObjectFactors.append(_CQLObjectPtr);
368 return _getObjectFactors[_getObjectFactors.size()-1]._ptr;
369 case Function:
370 case Value:
371 case ChainedIdentifier:
372 case Identifier:
373 return getObject(&(obj->getFactors()[0]),target);
|
374 humberto 1.1 default:
375 return NULL;
376 break;
377 }
|
378 chuck 1.3 }
|
379 humberto 1.1
|
380 chuck 1.3 void* CQLFactory::getObject(CQLExpression* obj, FactoryType target){
381 // printf("CQLFactory::getObject(CQLExpression* obj)\n");
382 switch(target){
383 case Term:
384 _CQLObjectPtr._ptr = new CQLTerm(obj->getTerms()[0]);
385 _getObjectTerms.append(_CQLObjectPtr);
386 return _getObjectTerms[_getObjectTerms.size()-1]._ptr;
387 case Factor:
388 case Function:
389 case Value:
390 case ChainedIdentifier:
391 case Identifier:
392 return getObject(&(obj->getTerms()[0]), target);
393 default:
394 return NULL;
395 break;
396 }
|
397 humberto 1.1 }
398
|
399 chuck 1.3 void* CQLFactory::getObject(CQLSimplePredicate* obj, FactoryType target){
400 // printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");
401 switch(target){
402 case Expression:
403 _CQLObjectPtr._ptr = new CQLExpression(obj->_rep->_leftSide);
404 _getObjectExpressions.append(_CQLObjectPtr);
405 return _getObjectExpressions[_getObjectExpressions.size()-1]._ptr;
406 case Term:
407 case Factor:
408 case Function:
409 case Value:
410 case ChainedIdentifier:
411 case Identifier:
412 return getObject(&(obj->_rep->_leftSide), target);
413 default:
414 return NULL;
415 break;
416 }
417 }
|
418 humberto 1.1
|
419 chuck 1.3 void* CQLFactory::getObject(CQLPredicate* obj, FactoryType target){
420 // printf("CQLFactory::getObject(CQLPredicate* obj)\n");
421 switch(target){
422 case SimplePredicate:
423 _CQLObjectPtr._ptr = new CQLSimplePredicate(obj->_rep->_simplePredicate);
424 _getObjectSimplePredicates.append(_CQLObjectPtr);
425 return _getObjectSimplePredicates[_getObjectSimplePredicates.size()-1]._ptr;
426 case Expression:
427 case Term:
428 case Factor:
429 case Function:
430 case Value:
431 case ChainedIdentifier:
432 case Identifier:
433 return getObject(&(obj->_rep->_simplePredicate), target);
434 default:
435 return NULL;
436 break;
437 }
438 }
439
440 chuck 1.3 void CQLFactory::setObject(CQLPredicate* predicate, void* obj, FactoryType objType){
|
441 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::setObject");
|
442 chuck 1.3 switch(objType){
443 case SimplePredicate:
444 predicate->_rep->_simplePredicate = *((CQLSimplePredicate*)obj);
445 break;
446 case Expression:
447 predicate->_rep->_simplePredicate._rep->_leftSide = *((CQLExpression*)obj);
448 break;
449 case Term:
450 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0] =
451 *((CQLTerm*)obj);
452 break;
453 case Factor:
454 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0] =
455 *((CQLFactor*)obj);
456 break;
457 case Function:
458 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLFunct =
459 *((CQLFunction*)obj);
460 break;
461 case Value:
462 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal =
463 chuck 1.3 *((CQLValue*)obj);
464 break;
465 case ChainedIdentifier:
466 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal._rep->_CQLChainId = *((CQLChainedIdentifier*)obj);
467 break;
468 case Identifier:
469 break;
470 default:
471 break;
472 }
|
473 humberto 1.4 PEG_METHOD_EXIT();
|
474 chuck 1.3 }
|
475 humberto 1.1 PEGASUS_NAMESPACE_END
|
Return to
CQLFactory.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / CQL