1 martin 1.15 //%LICENSE////////////////////////////////////////////////////////////////
|
2 martin 1.16 //
|
3 martin 1.15 // Licensed to The Open Group (TOG) under one or more contributor license
4 // agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
5 // this work for additional information regarding copyright ownership.
6 // Each contributor licenses this file to you under the OpenPegasus Open
7 // Source License; you may not use this file except in compliance with the
8 // License.
|
9 martin 1.16 //
|
10 martin 1.15 // Permission is hereby granted, free of charge, to any person obtaining a
11 // copy of this software and associated documentation files (the "Software"),
12 // to deal in the Software without restriction, including without limitation
13 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 // and/or sell copies of the Software, and to permit persons to whom the
15 // Software is furnished to do so, subject to the following conditions:
|
16 martin 1.16 //
|
17 martin 1.15 // The above copyright notice and this permission notice shall be included
18 // in all copies or substantial portions of the Software.
|
19 martin 1.16 //
|
20 martin 1.15 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
21 martin 1.16 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
22 martin 1.15 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
23 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
24 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
27 martin 1.16 //
|
28 martin 1.15 //////////////////////////////////////////////////////////////////////////
|
29 chuck 1.3 //
30 //%/////////////////////////////////////////////////////////////////////////////
31
|
32 humberto 1.1 #include "CQLFactory.h"
|
33 david.dillard 1.9 #include "CQLValueRep.h"
34 #include "CQLFactorRep.h"
35 #include "CQLSimplePredicateRep.h"
36 #include "CQLPredicateRep.h"
37 #include "CQLExpressionRep.h"
38 #include "CQLTermRep.h"
|
39 humberto 1.4 #include <Pegasus/Common/Tracer.h>
|
40 humberto 1.1
41 PEGASUS_NAMESPACE_BEGIN
42
|
43 chuck 1.3 CQLOBJECTPTR _CQLObjectPtr;
44
45 /*
46 #define PEGASUS_ARRAY_T CQLObjectPtr
47 #include <Pegasus/Common/ArrayImpl.h>
48 #undef PEGASUS_ARRAY_T
49 */
50
51 /*
|
52 karl 1.12 CQLFactory::CQLFactory()
53 {
|
54 chuck 1.3
55 }
56 */
|
57 karl 1.12 CQLFactory::~CQLFactory()
58 {
59 cleanup();
60 }
61
62 void CQLFactory::cleanup()
63 {
64 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::cleanup");
65
66 cleanupArray(_makeObjectIdentifiers, Identifier);
67 cleanupArray(_makeObjectChainedIdentifiers, ChainedIdentifier);
68 cleanupArray(_makeObjectValues, Value);
69 cleanupArray(_makeObjectFunctions, Function);
70 cleanupArray(_makeObjectFactors, Factor);
71 cleanupArray(_makeObjectTerms, Term);
72 cleanupArray(_makeObjectExpressions, Expression);
73 cleanupArray(_makeObjectSimplePredicates, SimplePredicate);
74 cleanupArray(_makeObjectPredicates, Predicate);
75 cleanupArray(_getObjectIdentifiers, Identifier);
76 cleanupArray(_getObjectChainedIdentifiers, ChainedIdentifier);
77 cleanupArray(_getObjectValues, Value);
78 karl 1.12 cleanupArray(_getObjectFunctions, Function);
79 cleanupArray(_getObjectFactors, Factor);
80 cleanupArray(_getObjectTerms, Term);
81 cleanupArray(_getObjectExpressions, Expression);
82 cleanupArray(_getObjectSimplePredicates, SimplePredicate);
83 cleanupArray(_getObjectPredicates, Predicate);
84
85 PEG_METHOD_EXIT();
86 }
87
88 void CQLFactory::cleanupArray(Array<CQLObjectPtr>& arr, FactoryType type)
89 {
90 for(Uint32 i=0;i < arr.size(); i++)
91 {
92 if(arr[i]._ptr)
93 {
94 switch(type)
95 {
96 case Predicate:
97 delete (CQLPredicate*)(arr[i]._ptr);
98 break;
99 karl 1.12 case SimplePredicate:
|
100 chuck 1.3 delete (CQLSimplePredicate*)(arr[i]._ptr);
101 break;
|
102 karl 1.12 case Expression:
|
103 chuck 1.3 delete (CQLExpression*)(arr[i]._ptr);
104 break;
|
105 karl 1.12 case Term:
|
106 chuck 1.3 delete (CQLTerm*)(arr[i]._ptr);
107 break;
|
108 karl 1.12 case Factor:
|
109 chuck 1.3 delete (CQLFactor*)(arr[i]._ptr);
110 break;
|
111 karl 1.12 case Function:
|
112 chuck 1.3 delete (CQLFunction*)(arr[i]._ptr);
113 break;
|
114 karl 1.12 case Value:
|
115 chuck 1.3 delete (CQLValue*)(arr[i]._ptr);
116 break;
|
117 karl 1.12 case ChainedIdentifier:
|
118 chuck 1.3 delete (CQLChainedIdentifier*)(arr[i]._ptr);
119 break;
|
120 karl 1.12 case Identifier:
|
121 chuck 1.3 delete (CQLIdentifier*)(arr[i]._ptr);
122 break;
|
123 karl 1.12 }
|
124 humberto 1.1 }
|
125 karl 1.12 }
|
126 humberto 1.1 }
|
127 karl 1.12
128 void* CQLFactory::makeObject(CQLIdentifier* obj, FactoryType target)
129 {
130 //printf("CQLFactory::makeObject(identifier)\n");
131 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLIdentifier");
132
133 void *cqlIdentifier = NULL;
134 _CQLObjectPtr._ptr = new CQLChainedIdentifier(*obj);
135 _makeObjectChainedIdentifiers.append(_CQLObjectPtr);
136
137 switch(target)
138 {
139 case ChainedIdentifier:
140 cqlIdentifier =
141 _makeObjectChainedIdentifiers[
142 _makeObjectChainedIdentifiers.size()-1]._ptr;
143 break;
144 case Identifier:
145 cqlIdentifier = NULL;
146 break;
147 default:
148 karl 1.12 cqlIdentifier = makeObject(
149 (CQLChainedIdentifier*)(_CQLObjectPtr._ptr), target);
150 break;
151 }
152 PEG_METHOD_EXIT();
153 return cqlIdentifier;
154 }
155
156 void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target)
157 {
158 //printf("CQLFactory::makeObject(chainedidentifier)\n");
159 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLChainedIdentifier");
|
160 carson.hovey 1.11
|
161 karl 1.12 void *cqlChainedIdentifier = NULL;
162 _CQLObjectPtr._ptr = new CQLValue(*obj);
163 _makeObjectValues.append(_CQLObjectPtr);
164 switch(target)
165 {
166 case Value:
167 cqlChainedIdentifier =
168 _makeObjectValues[_makeObjectValues.size()-1]._ptr;
169 break;
170 case ChainedIdentifier:
171 cqlChainedIdentifier = NULL;
172 break;
173 default:
174 cqlChainedIdentifier =
175 makeObject((CQLValue*)(_CQLObjectPtr._ptr), target);
176 break;
177 }
178 PEG_METHOD_EXIT();
179 return cqlChainedIdentifier;
180 }
181 void* CQLFactory::makeObject(CQLValue* obj, FactoryType target)
182 karl 1.12 {
183 //printf("CQLFactory::makeObject(value)\n");
184 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLValue");
185
186 void *cqlValue = NULL;
187 _CQLObjectPtr._ptr = new CQLFactor(*obj);
|
188 chuck 1.3 _makeObjectFactors.append(_CQLObjectPtr);
|
189 karl 1.12 switch(target)
190 {
191 case Factor:
192 cqlValue = _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
193 break;
194 case Value:
195 cqlValue = NULL;
196 break;
197 default:
198 cqlValue = makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
199 break;
200 }
201 PEG_METHOD_EXIT();
202 return cqlValue;
203 }
204 void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target)
205 {
206 //printf("CQLFactory::makeObject(function)\n");
207 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFunction");
208
209 void *cqlFunction = NULL;
210 karl 1.12 _CQLObjectPtr._ptr = new CQLFactor(*obj);
211 _makeObjectFactors.append(_CQLObjectPtr);
212 switch(target)
213 {
214 case Factor:
215 cqlFunction =
216 _makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
217 break;
218 default:
219 cqlFunction =
220 makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
221 break;
222 }
223 PEG_METHOD_EXIT();
224 return cqlFunction;
225 }
226 void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target)
227 {
228 //printf("CQLFactory::makeObject(factor)\n");
229 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFactor");
230
231 karl 1.12 void *cqlFactor = NULL;
232 _CQLObjectPtr._ptr = new CQLTerm(*obj);
|
233 chuck 1.3 _makeObjectTerms.append(_CQLObjectPtr);
|
234 karl 1.12 switch(target)
235 {
236 case Term:
237 cqlFactor = _makeObjectTerms[_makeObjectTerms.size()-1]._ptr;
238 break;
239 case Factor:
240 cqlFactor = NULL;
241 break;
242 default:
243 cqlFactor = makeObject((CQLTerm*)(_CQLObjectPtr._ptr), target);
244 break;
245 }
246 PEG_METHOD_EXIT();
247 return cqlFactor;
248 }
249 void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target)
250 {
251 //printf("CQLFactory::makeObject(term)\n");
252 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLTerm");
253
254 void *cqlTerm = NULL;
255 karl 1.12 _CQLObjectPtr._ptr = new CQLExpression(*obj);
|
256 chuck 1.3 _makeObjectExpressions.append(_CQLObjectPtr);
|
257 karl 1.12 switch(target)
258 {
259 case Expression:
260 cqlTerm =
261 _makeObjectExpressions[_makeObjectExpressions.size()-1]._ptr;
262 break;
263 case Term:
264 cqlTerm = NULL;
265 break;
266 default:
267 cqlTerm =
268 makeObject((CQLExpression*)(_CQLObjectPtr._ptr), target);
269 break;
270 }
271 PEG_METHOD_EXIT();
272 return cqlTerm;
273 }
274 void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target)
275 {
276 //printf("CQLFactory::makeObject(expression)\n");
277 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLExpression");
278 karl 1.12 void *cqlExpression = NULL;
279 _CQLObjectPtr._ptr = new CQLSimplePredicate(*obj);
280 _makeObjectSimplePredicates.append(_CQLObjectPtr);
281 switch(target)
282 {
283 case SimplePredicate:
284 cqlExpression =
285 _makeObjectSimplePredicates[
286 _makeObjectSimplePredicates.size()-1]._ptr;
287 break;
288 case Expression:
289 cqlExpression = NULL;
290 break;
291 default:
292 cqlExpression =
293 makeObject((CQLSimplePredicate*)(_CQLObjectPtr._ptr),
294 target);
295 break;
296 }
297 PEG_METHOD_EXIT();
298 return cqlExpression;
299 karl 1.12 }
300 void* CQLFactory::makeObject(CQLSimplePredicate* obj, FactoryType target)
301 {
302 //printf("CQLFactory::makeObject(simplepredicate)\n");
303 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLSimplePredicate");
304
305 void *cqlSimplePredicate = NULL;
306 _CQLObjectPtr._ptr = new CQLPredicate(*obj);
307 _makeObjectPredicates.append(_CQLObjectPtr);
308 switch(target){
309 case Predicate:
310 cqlSimplePredicate =
311 _makeObjectPredicates[_makeObjectPredicates.size()-1]._ptr;
312 break;
313 default:
314 cqlSimplePredicate = NULL;
315 break;
316 }
317 PEG_METHOD_EXIT();
318 return cqlSimplePredicate;
319 }
320 karl 1.12
321 void* CQLFactory::getObject(void* inObject, FactoryType inObjectType,
322 FactoryType targetType)
323 {
324 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::getObject");
325 void * obj = NULL;
326
327 switch(inObjectType)
328 {
329 case Predicate:
330 obj = getObject(((CQLPredicate*)inObject),targetType);
331 break;
332 case SimplePredicate:
333 obj = getObject(((CQLSimplePredicate*)inObject),targetType);
334 break;
335 case Expression:
336 obj = getObject(((CQLExpression*)inObject),targetType);
337 break;
338 case Term:
339 obj = getObject(((CQLTerm*)inObject),targetType);
340 break;
341 karl 1.12 case Factor:
342 obj = getObject(((CQLFactor*)inObject),targetType);
343 break;
344 case Function:
345 obj = NULL;
346 break;
347 case Value:
348 obj = getObject(((CQLValue*)inObject),targetType);
349 break;
350 case ChainedIdentifier:
351 obj = getObject(((CQLChainedIdentifier*)inObject),targetType);
352 break;
353 default:
354 obj = NULL;
355 break;
356 }
357
358 PEG_METHOD_EXIT();
359 return obj;
360 }
361
362 karl 1.12 void* CQLFactory::getObject(CQLChainedIdentifier* obj, FactoryType target)
363 {
364 // printf("CQLFactory::getObject(CQLChainedIdentifier* obj)\n");
365 Array<CQLIdentifier> cqlIds;
366
367 switch(target)
368 {
369 case Identifier:
|
370 chuck 1.3 //if(obj->_rep->_subIdentifiers.size() > 0){
|
371 karl 1.12 cqlIds = obj->getSubIdentifiers();
372 if(cqlIds.size() > 0)
373 {
374 // _CQLObjectPtr._ptr =
375 // new CQLIdentifier(obj->_rep->_subIdentifiers[0]);
376 _CQLObjectPtr._ptr = new CQLIdentifier(cqlIds[0]);
377 _getObjectIdentifiers.append(_CQLObjectPtr);
378 return _getObjectIdentifiers[
379 _getObjectIdentifiers.size()-1]._ptr;
380 }
381 return NULL;
382 default:
383 return NULL;
384 }
385 }
386
387 void* CQLFactory::getObject(CQLValue* obj, FactoryType target)
388 {
389 // printf("CQLFactory::getObject(CQLValue* obj)\n");
390 switch(target)
391 {
392 karl 1.12 case ChainedIdentifier:
393 _CQLObjectPtr._ptr =
394 new CQLChainedIdentifier(obj->_rep->_CQLChainId);
395 _getObjectChainedIdentifiers.append(_CQLObjectPtr);
396 return _getObjectChainedIdentifiers[
397 _getObjectChainedIdentifiers.size()-1]._ptr;
398 case Identifier:
399 return getObject(&(obj->_rep->_CQLChainId),target);
400 default:
401 return NULL;
402 break;
403 }
404 }
405
406 void* CQLFactory::getObject(CQLFactor* obj, FactoryType target)
407 {
408 // printf("CQLFactory::getObject(CQLFactor* obj)\n");
409 switch(target)
410 {
411 case Function:
412 _CQLObjectPtr._ptr = new CQLFunction(obj->_rep->_CQLFunct);
|
413 chuck 1.3 _getObjectFunctions.append(_CQLObjectPtr);
|
414 karl 1.12 return _getObjectFunctions[_getObjectFunctions.size()-1]._ptr;
415 case Value:
416 _CQLObjectPtr._ptr = new CQLValue(obj->_rep->_CQLVal);
417 _getObjectValues.append(_CQLObjectPtr);
418 return _getObjectValues[_getObjectValues.size()-1]._ptr;
419 case ChainedIdentifier:
420 case Identifier:
421 return getObject(&(obj->_rep->_CQLVal),target);
422 default:
423 return NULL;
424 break;
425 }
426 }
427
428 void* CQLFactory::getObject(CQLTerm* obj, FactoryType target)
429 {
430 // printf("CQLFactory::getObject(CQLTerm* obj)\n");
431 switch(target)
432 {
433 case Factor:
434 _CQLObjectPtr._ptr = new CQLFactor(obj->getFactors()[0]);
|
435 chuck 1.3 _getObjectFactors.append(_CQLObjectPtr);
|
436 karl 1.12 return _getObjectFactors[_getObjectFactors.size()-1]._ptr;
437 case Function:
438 case Value:
439 case ChainedIdentifier:
440 case Identifier:
441 return getObject(&(obj->getFactors()[0]),target);
442 default:
443 return NULL;
444 break;
445 }
446 }
447
448 void* CQLFactory::getObject(CQLExpression* obj, FactoryType target)
449 {
450 // printf("CQLFactory::getObject(CQLExpression* obj)\n");
451 switch(target)
452 {
453 case Term:
454 _CQLObjectPtr._ptr = new CQLTerm(obj->getTerms()[0]);
|
455 chuck 1.3 _getObjectTerms.append(_CQLObjectPtr);
|
456 karl 1.12 return _getObjectTerms[_getObjectTerms.size()-1]._ptr;
457 case Factor:
458 case Function:
459 case Value:
460 case ChainedIdentifier:
461 case Identifier:
462 return getObject(&(obj->getTerms()[0]), target);
463 default:
464 return NULL;
465 break;
466 }
467 }
468
469 void* CQLFactory::getObject(CQLSimplePredicate* obj, FactoryType target)
470 {
471 // printf("CQLFactory::getObject(CQLSimplePredicate* obj)\n");
472 switch(target)
473 {
474 case Expression:
475 _CQLObjectPtr._ptr = new CQLExpression(obj->_rep->_leftSide);
476 _getObjectExpressions.append(_CQLObjectPtr);
477 karl 1.12 return _getObjectExpressions[_getObjectExpressions.size()-1]._ptr;
478 case Term:
479 case Factor:
480 case Function:
481 case Value:
482 case ChainedIdentifier:
483 case Identifier:
484 return getObject(&(obj->_rep->_leftSide), target);
485 default:
486 return NULL;
487 break;
488 }
489 }
490
491 void* CQLFactory::getObject(CQLPredicate* obj, FactoryType target)
492 {
493 // printf("CQLFactory::getObject(CQLPredicate* obj)\n");
494 switch(target)
495 {
496 case SimplePredicate:
497 _CQLObjectPtr._ptr =
498 karl 1.12 new CQLSimplePredicate(obj->_rep->_simplePredicate);
|
499 chuck 1.3 _getObjectSimplePredicates.append(_CQLObjectPtr);
|
500 karl 1.12 return _getObjectSimplePredicates[
501 _getObjectSimplePredicates.size()-1]._ptr;
502 case Expression:
503 case Term:
504 case Factor:
505 case Function:
506 case Value:
507 case ChainedIdentifier:
508 case Identifier:
509 return getObject(&(obj->_rep->_simplePredicate), target);
510 default:
511 return NULL;
512 break;
513 }
514 }
515
516 void CQLFactory::setObject(CQLPredicate* predicate, void* obj,
517 FactoryType objType)
518 {
519 PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::setObject");
520 switch(objType)
521 karl 1.12 {
522 case SimplePredicate:
523 predicate->_rep->_simplePredicate = *((CQLSimplePredicate*)obj);
524 break;
525 case Expression:
526 predicate->_rep->_simplePredicate._rep->_leftSide =
527 *((CQLExpression*)obj);
528 break;
529 case Term:
|
530 karl 1.13 predicate->_rep->_simplePredicate._rep->_leftSide._rep->
531 _CQLTerms[0] = *((CQLTerm*)obj);
|
532 karl 1.12 break;
533 case Factor:
534 predicate->_rep->_simplePredicate._rep->
535 _leftSide._rep->_CQLTerms[0]._rep->_Factors[0] =
536 *((CQLFactor*)obj);
537 break;
538 case Function:
539 predicate->_rep->_simplePredicate._rep->_leftSide._rep->
540 _CQLTerms[0]._rep->_Factors[0]._rep->_CQLFunct =
541 *((CQLFunction*)obj);
542 break;
543 case Value:
544 predicate->_rep->_simplePredicate._rep->_leftSide._rep->
545 _CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal =
546 *((CQLValue*)obj);
547 break;
548 case ChainedIdentifier:
549 predicate->_rep->_simplePredicate._rep->_leftSide._rep->
|
550 karl 1.13 _CQLTerms[0]._rep->_Factors[0]._rep->_CQLVal._rep->_CQLChainId
551 = *((CQLChainedIdentifier*)obj);
|
552 karl 1.12 break;
553 case Identifier:
554 break;
555 default:
556 break;
557 }
558 PEG_METHOD_EXIT();
|
559 chuck 1.3 }
|
560 humberto 1.1 PEGASUS_NAMESPACE_END
|
Return to
CQLFactory.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / CQL