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 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::getObject");
|
261 chuck 1.3 switch(inObjectType){
262 case Predicate:
|
263 carson.hovey 1.7 {
264 PEG_METHOD_EXIT();
|
265 chuck 1.3 return getObject(((CQLPredicate*)inObject),targetType);
|
266 carson.hovey 1.7 }
|
267 chuck 1.3 case SimplePredicate:
|
268 carson.hovey 1.7 {
269 PEG_METHOD_EXIT();
|
270 chuck 1.3 return getObject(((CQLSimplePredicate*)inObject),targetType);
|
271 carson.hovey 1.7 }
|
272 chuck 1.3 case Expression:
|
273 carson.hovey 1.7 {
274 PEG_METHOD_EXIT();
|
275 chuck 1.3 return getObject(((CQLExpression*)inObject),targetType);
|
276 carson.hovey 1.7 }
|
277 chuck 1.3 case Term:
|
278 carson.hovey 1.7 {
279 PEG_METHOD_EXIT();
|
280 chuck 1.3 return getObject(((CQLTerm*)inObject),targetType);
|
281 carson.hovey 1.7 }
|
282 chuck 1.3 case Factor:
|
283 carson.hovey 1.7 {
284 PEG_METHOD_EXIT();
|
285 chuck 1.3 return getObject(((CQLFactor*)inObject),targetType);
|
286 carson.hovey 1.7 }
|
287 chuck 1.3 case Function:
|
288 carson.hovey 1.7 {
289 PEG_METHOD_EXIT();
|
290 chuck 1.3 return NULL;
|
291 carson.hovey 1.7 }
|
292 chuck 1.3 case Value:
|
293 carson.hovey 1.7 {
294 PEG_METHOD_EXIT();
|
295 chuck 1.3 return getObject(((CQLValue*)inObject),targetType);
|
296 carson.hovey 1.7 }
|
297 chuck 1.3 case ChainedIdentifier:
|
298 carson.hovey 1.7 {
299 PEG_METHOD_EXIT();
|
300 chuck 1.3 return getObject(((CQLChainedIdentifier*)inObject),targetType);
|
301 carson.hovey 1.7 }
|
302 chuck 1.3 default:
|
303 carson.hovey 1.7 {
304 PEG_METHOD_EXIT();
|
305 chuck 1.3 return NULL;
|
306 carson.hovey 1.7 }
|
307 chuck 1.3 }
308 }
309
310 void* CQLFactory::getObject(CQLChainedIdentifier* obj, FactoryType target){
311 // printf("CQLFactory::getObject(CQLChainedIdentifier* obj)\n");
312 Array<CQLIdentifier> cqlIds;
313
314 switch(target){
315 case Identifier:
316 //if(obj->_rep->_subIdentifiers.size() > 0){
317 cqlIds = obj->getSubIdentifiers();
318 if(cqlIds.size() > 0){
319
320 // _CQLObjectPtr._ptr = new CQLIdentifier(obj->_rep->_subIdentifiers[0]);
321 _CQLObjectPtr._ptr = new CQLIdentifier(cqlIds[0]);
322 _getObjectIdentifiers.append(_CQLObjectPtr);
323 return _getObjectIdentifiers[_getObjectIdentifiers.size()-1]._ptr;
324 }
325 return NULL;
326 default:
327 return NULL;
328 chuck 1.3 }
329 }
330
331 void* CQLFactory::getObject(CQLValue* obj, FactoryType target){
332 // printf("CQLFactory::getObject(CQLValue* obj)\n");
333 switch(target){
334 case ChainedIdentifier:
335 _CQLObjectPtr._ptr = new CQLChainedIdentifier(obj->_rep->_CQLChainId);
336 _getObjectChainedIdentifiers.append(_CQLObjectPtr);
337 return _getObjectChainedIdentifiers[_getObjectChainedIdentifiers.size()-1]._ptr;
338 case Identifier:
339 return getObject(&(obj->_rep->_CQLChainId),target);
340 default:
341 return NULL;
342 break;
343 }
344 }
345
346 void* CQLFactory::getObject(CQLFactor* obj, FactoryType target){
347 // printf("CQLFactory::getObject(CQLFactor* obj)\n");
348 switch(target){
349 chuck 1.3 case Function:
350 _CQLObjectPtr._ptr = new CQLFunction(obj->_rep->_CQLFunct);
351 _getObjectFunctions.append(_CQLObjectPtr);
352 return _getObjectFunctions[_getObjectFunctions.size()-1]._ptr;
353 case Value:
354 _CQLObjectPtr._ptr = new CQLValue(obj->_rep->_CQLVal);
355 _getObjectValues.append(_CQLObjectPtr);
356 return _getObjectValues[_getObjectValues.size()-1]._ptr;
357 case ChainedIdentifier:
358 case Identifier:
359 return getObject(&(obj->_rep->_CQLVal),target);
360 default:
361 return NULL;
|
362 humberto 1.1 break;
|
363 chuck 1.3 }
364 }
365
366
367 void* CQLFactory::getObject(CQLTerm* obj, FactoryType target){
368 // printf("CQLFactory::getObject(CQLTerm* obj)\n");
369 switch(target){
370 case Factor:
371 _CQLObjectPtr._ptr = new CQLFactor(obj->getFactors()[0]);
372 _getObjectFactors.append(_CQLObjectPtr);
373 return _getObjectFactors[_getObjectFactors.size()-1]._ptr;
374 case Function:
375 case Value:
376 case ChainedIdentifier:
377 case Identifier:
378 return getObject(&(obj->getFactors()[0]),target);
|
379 humberto 1.1 default:
380 return NULL;
381 break;
382 }
|
383 chuck 1.3 }
|
384 humberto 1.1
|
385 chuck 1.3 void* CQLFactory::getObject(CQLExpression* obj, FactoryType target){
386 // printf("CQLFactory::getObject(CQLExpression* obj)\n");
387 switch(target){
388 case Term:
389 _CQLObjectPtr._ptr = new CQLTerm(obj->getTerms()[0]);
390 _getObjectTerms.append(_CQLObjectPtr);
391 return _getObjectTerms[_getObjectTerms.size()-1]._ptr;
392 case Factor:
393 case Function:
394 case Value:
395 case ChainedIdentifier:
396 case Identifier:
397 return getObject(&(obj->getTerms()[0]), target);
398 default:
399 return NULL;
400 break;
401 }
|
402 humberto 1.1 }
403
|
404 chuck 1.3 void* CQLFactory::getObject(CQLSimplePredicate* obj, FactoryType target){
405 // printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");
406 switch(target){
407 case Expression:
408 _CQLObjectPtr._ptr = new CQLExpression(obj->_rep->_leftSide);
409 _getObjectExpressions.append(_CQLObjectPtr);
410 return _getObjectExpressions[_getObjectExpressions.size()-1]._ptr;
411 case Term:
412 case Factor:
413 case Function:
414 case Value:
415 case ChainedIdentifier:
416 case Identifier:
417 return getObject(&(obj->_rep->_leftSide), target);
418 default:
419 return NULL;
420 break;
421 }
422 }
|
423 humberto 1.1
|
424 chuck 1.3 void* CQLFactory::getObject(CQLPredicate* obj, FactoryType target){
425 // printf("CQLFactory::getObject(CQLPredicate* obj)\n");
426 switch(target){
427 case SimplePredicate:
428 _CQLObjectPtr._ptr = new CQLSimplePredicate(obj->_rep->_simplePredicate);
429 _getObjectSimplePredicates.append(_CQLObjectPtr);
430 return _getObjectSimplePredicates[_getObjectSimplePredicates.size()-1]._ptr;
431 case Expression:
432 case Term:
433 case Factor:
434 case Function:
435 case Value:
436 case ChainedIdentifier:
437 case Identifier:
438 return getObject(&(obj->_rep->_simplePredicate), target);
439 default:
440 return NULL;
441 break;
442 }
443 }
444
445 chuck 1.3 void CQLFactory::setObject(CQLPredicate* predicate, void* obj, FactoryType objType){
|
446 humberto 1.4 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::setObject");
|
447 chuck 1.3 switch(objType){
448 case SimplePredicate:
449 predicate->_rep->_simplePredicate = *((CQLSimplePredicate*)obj);
450 break;
451 case Expression:
452 predicate->_rep->_simplePredicate._rep->_leftSide = *((CQLExpression*)obj);
453 break;
454 case Term:
455 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0] =
456 *((CQLTerm*)obj);
457 break;
458 case Factor:
459 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0] =
460 *((CQLFactor*)obj);
461 break;
462 case Function:
463 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLFunct =
464 *((CQLFunction*)obj);
465 break;
466 case Value:
467 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal =
468 chuck 1.3 *((CQLValue*)obj);
469 break;
470 case ChainedIdentifier:
471 predicate->_rep->_simplePredicate._rep->_leftSide._rep->_CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal._rep->_CQLChainId = *((CQLChainedIdentifier*)obj);
472 break;
473 case Identifier:
474 break;
475 default:
476 break;
477 }
|
478 humberto 1.4 PEG_METHOD_EXIT();
|
479 chuck 1.3 }
|
480 humberto 1.1 PEGASUS_NAMESPACE_END
|
Return to
CQLFactory.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / CQL