1 karl 1.24 //%2006////////////////////////////////////////////////////////////////////////
|
2 chuck 1.2 //
|
3 karl 1.18 // 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.2 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.18 // 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.24 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 chuck 1.2 //
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 // Author: Dave Rosckes (rosckes@us.ibm.com)
33 //
34 chuck 1.2 // Modified By: Dan Gorey (djgorey@us.ibm.com)
|
35 vijay.eli 1.22 // Vijay Eli, IBM (vijayeli@in.ibm.com) bug#3590
|
36 chuck 1.2 //
37 //%/////////////////////////////////////////////////////////////////////////////
38 #include <Pegasus/CQL/CQLValue.h>
39 #include <Pegasus/CQL/CQLValueRep.h>
40 #include <Pegasus/Repository/NameSpaceManager.h>
41 #include <Pegasus/Common/CIMClass.h>
42 #include <Pegasus/Common/Tracer.h>
43 #include <Pegasus/CQL/CQLIdentifier.h>
44 #include <Pegasus/CQL/CQLRegularExpression.h>
45 #include <Pegasus/CQL/CQLFactory.h>
46 #include <Pegasus/Query/QueryCommon/QueryException.h>
|
47 david 1.4 #include <Pegasus/CQL/CQLUtilities.h>
|
48 chuck 1.2
49
50 PEGASUS_NAMESPACE_BEGIN
51 PEGASUS_USING_STD;
52
53 /*
54 #define PEGASUS_ARRAY_T CQLValueRep
55 #include <Pegasus/Common/ArrayImpl.h>
56 #undef PEGASUS_ARRAY_T
57 */
58
59 #define PEGASUS_SINT64_MIN (PEGASUS_SINT64_LITERAL(0x8000000000000000))
60 #define PEGASUS_UINT64_MAX PEGASUS_UINT64_LITERAL(0xFFFFFFFFFFFFFFFF)
|
61 david 1.8
|
62 chuck 1.2
63 CQLValueRep::CQLValueRep()
|
64 humberto 1.17 :_theValue(),_CQLChainId(),_isResolved(false),_valueType(CQLValue::Null_type)
|
65 chuck 1.2 {
66 }
67
68 CQLValueRep::~CQLValueRep()
69 {
70
71 }
72
73
|
74 humberto 1.16 CQLValueRep::CQLValueRep(const CQLValueRep& val):
75 _theValue(val._theValue),
76 _CQLChainId(val._CQLChainId),
77 _isResolved(val._isResolved),
78 _valueType(val._valueType),
79 _ArrayType(val._ArrayType)
|
80 chuck 1.2 {
81
82 }
83
|
84 humberto 1.16 CQLValueRep::CQLValueRep(const CQLValueRep* val):
85 _theValue(val->_theValue),
86 _CQLChainId(val->_CQLChainId),
87 _isResolved(val->_isResolved),
88 _valueType(val->_valueType),
89 _ArrayType(val->_ArrayType)
|
90 chuck 1.2 {
91 }
92
93 CQLValueRep::CQLValueRep(const String& inString, CQLValue::NumericType inValueType, Boolean inSign)
94 {
95 PEG_METHOD_ENTER(TRC_CQL, "CQLValueRep::CQLValueRep()");
96
97 switch(inValueType)
98 {
|
99 david 1.4 case CQLValue::Hex:
100 {
|
101 david 1.7 String tmp(inString);
|
102 david 1.4 if(inSign)
103 {
104 _theValue.set(CQLUtilities::stringToUint64(tmp));
105 _valueType = CQLValue::Uint64_type;
106 }
107 else
108 {
109 _theValue.set(CQLUtilities::stringToSint64(inString));
110 _valueType = CQLValue::Sint64_type;
111 }
112 }
113 break;
114 case CQLValue::Binary:
115 {
|
116 david 1.7 String tmp(inString);;
|
117 david 1.4 if(inSign)
118 {
119 _theValue.set(CQLUtilities::stringToUint64(tmp));
120 _valueType = CQLValue::Uint64_type;
121 }
122 else
123 {
124 _theValue.set(CQLUtilities::stringToSint64(tmp));
125 _valueType = CQLValue::Sint64_type;
126 }
127 break;
128 }
129 case CQLValue::Decimal:
130 {
|
131 david 1.7 String tmp(inString);
|
132 david 1.4 if(inSign)
133 {
134 _theValue.set(CQLUtilities::stringToUint64(tmp));
135 _valueType = CQLValue::Uint64_type;
136 }
137 else
138 {
139 _theValue.set(CQLUtilities::stringToSint64(tmp));
140 _valueType = CQLValue::Sint64_type;
141 }
142 }
143 break;
144 case CQLValue::Real:
145 {
|
146 david 1.7 String tmp(inString);
|
147 humberto 1.16
148 _theValue.set(CQLUtilities::stringToReal64(tmp));
149 _valueType = CQLValue::Real_type;
|
150 david 1.4 }
151 break;
152 default:
153 MessageLoaderParms mload(String("CQL.CQLValueRep.CONSTRUCTOR_FAILURE"),
|
154 humberto 1.16 String("Undefined case:$0 in constructor."),
155 inValueType);
|
156 david 1.4 throw CQLRuntimeException(mload);
157
158 break;
|
159 chuck 1.2 }
|
160 david 1.4
|
161 chuck 1.2 _isResolved = true;
|
162 david 1.4
|
163 chuck 1.2 PEG_METHOD_EXIT();
164 }
165
166
167 CQLValueRep::CQLValueRep(const CQLChainedIdentifier& inCQLIdent)
168 : _CQLChainId(inCQLIdent),
169 _isResolved(false),
170 _valueType(CQLValue::CQLIdentifier_type)
171 {
172
173 }
174
175
176 CQLValueRep::CQLValueRep(const String& inString)
177 : _isResolved(true),
178 _valueType(CQLValue::String_type)
179 {
180 _theValue.set(inString);
181 }
182
183 CQLValueRep::CQLValueRep(const CIMInstance& inInstance)
184 chuck 1.2 : _isResolved(true),
185 _valueType(CQLValue::CIMObject_type)
186 {
|
187 david 1.5 _theValue.set((CIMObject)inInstance);
|
188 chuck 1.2 }
189
190 CQLValueRep::CQLValueRep(const CIMClass& inClass)
191 : _isResolved(true),
192 _valueType(CQLValue::CIMObject_type)
193 {
|
194 david 1.5 _theValue.set((CIMObject)inClass);
|
195 chuck 1.2 }
196
197 CQLValueRep::CQLValueRep(const CIMObject& inObject)
198 : _isResolved(true),
199 _valueType(CQLValue::CIMObject_type)
200 {
|
201 david 1.6 _theValue.set((CIMObject)inObject);
|
202 chuck 1.2 }
203
204 CQLValueRep::CQLValueRep(const CIMObjectPath& inObjPath)
205 : _isResolved(true),
206 _valueType(CQLValue::CIMReference_type)
207 {
208 _theValue.set(inObjPath);
209 }
210
211 CQLValueRep::CQLValueRep(const CIMDateTime& inDateTime)
212 : _isResolved(true),
213 _valueType(CQLValue::CIMDateTime_type)
214 {
215 _theValue.set(inDateTime);
216 }
217
218 CQLValueRep::CQLValueRep(Uint64 inUint)
219 : _isResolved(true),
220 _valueType(CQLValue::Uint64_type)
221 {
222 _theValue.set(inUint);
223 chuck 1.2 }
224
225 CQLValueRep::CQLValueRep(Boolean inBool)
226 : _isResolved(true),
227 _valueType(CQLValue::Boolean_type)
228 {
229 _theValue.set(inBool);
230 }
231
232 CQLValueRep::CQLValueRep(Sint64 inSint)
233 : _isResolved(true),
234 _valueType(CQLValue::Sint64_type)
235 {
236 _theValue.set(inSint);
237 }
238
239 CQLValueRep::CQLValueRep(Real64 inReal)
240 : _isResolved(true),
241 _valueType(CQLValue::Real_type)
242 {
243 _theValue.set(inReal);
244 chuck 1.2 }
245
246 CQLValueRep::CQLValueRep(const CIMValue& inVal)
|
247 humberto 1.16 : _isResolved(true)
|
248 chuck 1.2 {
|
249 humberto 1.16 // _valueType is set by _setValue
|
250 chuck 1.2 _setValue(inVal);
251 }
252
253 void CQLValueRep::resolve(const CIMInstance& CI, const QueryContext& inQueryCtx)
254 {
255 if(_CQLChainId.size() == 0)
256 {
257 return;
258 }
259
260
261 Array<CQLIdentifier> Idstrings =
262 _CQLChainId.getSubIdentifiers(); // Array of Identifiers to process
|
263 humberto 1.16 Uint32 IdSize = Idstrings.size();
|
264 chuck 1.2 Uint32 index = 0; // Counter for looping through Identifiers
265 CIMProperty propObj;
266
|
267 humberto 1.16 if(IdSize == 1)
|
268 chuck 1.2 {
269 // A class was passed in with no property indicated.
270 // Set the instance passed in, as a primitive.
|
271 david 1.5 _theValue.set((CIMObject)CI);
|
272 chuck 1.2 _valueType = CQLValue::CIMObject_type;
273 _isResolved = true;
274 return; // Done.
275 }
276 else
277 {
278 // Symbolic Constant processing
279 if(_CQLChainId.getLastIdentifier().isSymbolicConstant() &&
|
280 humberto 1.16 IdSize == 2)
|
281 chuck 1.2 {
282 _resolveSymbolicConstant(inQueryCtx);
283 return;
284 }
285
286 // Need to increment index since the first Identifier is a class,
287 // and additional identifiers need processing.
288 ++index;
289 }
290
291 CIMName classContext = Idstrings[0].getName();
292 CIMObject objectContext = CI;
293
|
294 humberto 1.16 for(;index < IdSize; ++index)
|
295 chuck 1.2 {
296 // Now we need to verify that the property is in the class.
297 Uint32 propertyIndex = objectContext.findProperty(Idstrings[index].getName());
298
299 if(propertyIndex == PEG_NOT_FOUND)
300 {
301 _valueType = CQLValue::Null_type;
|
302 david 1.20 _isResolved = true;
|
303 chuck 1.2 return;
304 }
305
306 // We will check the property type to determine what processing
307 // needs to be done.
308 propObj = objectContext.getProperty(propertyIndex);
309
|
310 david 1.12 try
311 {
|
312 humberto 1.16 if((Idstrings[index].isScoped() && inQueryCtx.getClassRelation(Idstrings[index].getScope(),objectContext.getClassName())
313 == QueryContext::NOTRELATED) ||
314 (Idstrings[index].isScoped() && inQueryCtx.getClassRelation(Idstrings[index].getScope(),objectContext.getClassName())
315 == QueryContext::SUPERCLASS))
|
316 david 1.12 {
317 // The chain is not inline with scope.
318 _valueType = CQLValue::Null_type;
|
319 david 1.20 _isResolved = true;
|
320 david 1.12 return;
321 }
322 }
|
323 david.dillard 1.21 catch(const CIMException &)
|
324 chuck 1.2 {
325 // The chain is not inline with scope.
326 _valueType = CQLValue::Null_type;
|
327 david 1.20 _isResolved = true;
|
328 chuck 1.2 return;
329 }
|
330 david 1.12
|
331 chuck 1.2
|
332 humberto 1.16 if(index == IdSize-1)
|
333 chuck 1.2 {
334 _process_value(propObj,Idstrings[index],inQueryCtx);
335 return;
336 }
|
337 humberto 1.16 else if((propObj.getType() != CIMTYPE_OBJECT) ||
338 (propObj.getValue().isNull()))
|
339 chuck 1.2 {
340 // Object is not embedded.
341 _valueType = CQLValue::Null_type;
|
342 david 1.20 _isResolved = true;
|
343 chuck 1.2 return;
344 }
|
345 david 1.5 propObj.getValue().get(objectContext);
|
346 humberto 1.16 if(!objectContext.isInstance())
347 {
348 MessageLoaderParms mparms("CQL.CQLValueRep.OBJECT_CONTEXT_NOT_INSTANCE",
349 "The object context $0 is not an instance.",
350 objectContext.getClassName().getString());
351 throw CQLRuntimeException(mparms);
352 }
|
353 david 1.5 classContext = objectContext.getClassName();
|
354 chuck 1.2 }
355 } // end of function
356
357 void CQLValueRep::_process_value(CIMProperty& propObj,
358 CQLIdentifier& _id,
359 const QueryContext& inQueryCtx)
360 {
|
361 david 1.8 if(propObj.getType() == CIMTYPE_OBJECT)
|
362 chuck 1.2 {
363 CIMObject cimObj;
364 propObj.getValue().get(cimObj);
365
|
366 humberto 1.16 _theValue.set(cimObj.clone());
|
367 chuck 1.2 _valueType = CQLValue::CIMObject_type;
|
368 david 1.20 _isResolved = true;
|
369 chuck 1.2 }
370 else // Primitive
371 {
372 if(_id.isArray())
373 {
374 // We have an array property. All we need to do
375 // Is get the index defined by CQLIdentifier.
376 // NOTE: Basic CQL support only allows one index.
377 _setValue(propObj.getValue(),
378 _id.getSubRanges()[0].start);
379 return;
380 }
381 else if(_id.isSymbolicConstant())
382 {
383 // Symbolic Constant processing
384 _resolveSymbolicConstant(inQueryCtx);
385 return;
386 }
387 else
388 {
389 // The property has no special charactors.
390 chuck 1.2 if(propObj.isArray())
391 {
392 Uint32 qualIndex = propObj.findQualifier(CIMName(String("ArrayType")));
|
393 humberto 1.16 if(qualIndex == PEG_NOT_FOUND)
394 {
395 // Default Array type
396 _ArrayType = String("Indexed");
397 }
398 else
399 {
400 propObj.getQualifier(qualIndex).getValue().get(_ArrayType);
401 }
|
402 chuck 1.2 }
403 _setValue(propObj.getValue());
404 return;
405 }
406 }
407 }
408
409 CQLValueRep& CQLValueRep::operator=(const CQLValueRep& rhs)
410 {
411
412 if(&rhs != this)
413 {
414 _valueType = rhs._valueType;
415 _theValue = rhs._theValue;
416 _CQLChainId = rhs._CQLChainId;
417 _isResolved = rhs._isResolved;
|
418 humberto 1.16 _ArrayType = rhs._ArrayType;
|
419 chuck 1.2 }
420 return *this;
421 }
422 Boolean CQLValueRep::operator==(const CQLValueRep& x)
423 {
424 PEG_METHOD_ENTER(TRC_CQL, "CQLValueRep::operator==");
425 _validate(x);
426
|
427 humberto 1.16 if(_theValue.isNull() && x._theValue.isNull())
428 {
429 return true;
430 }
431 if(_theValue.isNull() || x._theValue.isNull())
432 {
433 return false;
434 }
435
|
436 chuck 1.2 if(_theValue.isArray())
437 {
438 return _compareArray(x);
439 }
440 else if((_theValue.getType() == x._theValue.getType()) &&
441 (_valueType != CQLValue::CIMObject_type) &&
442 (_valueType != CQLValue::CQLIdentifier_type))
443 {
444 return _theValue == x._theValue;
445 }
446 else
447 {
448 Uint64 tmpU64;
449 Sint64 tmpS64;
450 Real64 tmpR64;
451
452 switch(_valueType)
453 {
454 case CQLValue::Null_type:
455 {
456 if(x._valueType == CQLValue::Null_type)
457 chuck 1.2 {
458 return true;
459 }
460 }
461 break;
462
463 case CQLValue::Sint64_type:
464 {
465 _theValue.get(tmpS64);
466 if(x._valueType == CQLValue::Uint64_type)
467 {
468 x._theValue.get(tmpU64);
469
|
470 humberto 1.16 if(tmpU64 >= (Uint64)PEGASUS_SINT64_MIN)
|
471 chuck 1.2 {
472 return false;
473 }
474 else
475 {
476 return (Sint64)tmpU64 == tmpS64;
477 }
478 }
479 else
480 {
481 x._theValue.get(tmpR64);
482
483 return tmpR64 == tmpS64;
484 }
485 break;
486 }
487 case CQLValue::Uint64_type:
488 {
489 _theValue.get(tmpU64);
490 if(x._valueType == CQLValue::Sint64_type)
491 {
492 chuck 1.2 x._theValue.get(tmpS64);
493
|
494 humberto 1.16 if(tmpU64 >= (Uint64)PEGASUS_SINT64_MIN)
|
495 chuck 1.2 {
496 return false;
497 }
498 else
499 {
500 return (Sint64)tmpU64 == tmpS64;
501 }
502 }
503 else
504 {
505 x._theValue.get(tmpR64);
|
506 humberto 1.16 if(tmpU64 >= (Uint64)PEGASUS_SINT64_MIN)
|
507 chuck 1.2 {
508 return false;
509 }
510 else
511 {
512 return tmpR64 == (Sint64)tmpU64;
513 }
514 }
515 break;
516 }
517 case CQLValue::Real_type:
518 {
519 _theValue.get(tmpR64);
520 if(x._valueType == CQLValue::Uint64_type)
521 {
522 x._theValue.get(tmpU64);
523
|
524 humberto 1.16 if(tmpU64 >= (Uint64)PEGASUS_SINT64_MIN)
|
525 chuck 1.2 {
526 return false;
527 }
528 else
529 {
530 return (Sint64)tmpU64 == tmpR64;
531 }
532 }
533 else
534 {
535 x._theValue.get(tmpS64);
536
537 return tmpR64 == tmpS64;
538 }
539 break;
540 }
541 case CQLValue::CIMObject_type:
542 {
543 CIMObject objBase;
544 CIMObject objParm;
545 _theValue.get(objBase);
546 chuck 1.2 x._theValue.get(objParm);
|
547 david 1.5
548 return _compareObjects(objBase,objParm);
|
549 chuck 1.2
550 }
551 break;
552
553 default:
554 MessageLoaderParms mload(String("CQL.CQLValueRep.CONSTRUCTOR_FAILURE"),
|
555 humberto 1.16 String("Undefined case:$0 in constructor."),
556 _valueType);
|
557 chuck 1.2 throw CQLRuntimeException(mload);
558 break;
559 }
560 return false;
561 }
562 }
563
564 Boolean CQLValueRep::operator!=(const CQLValueRep& x)
565 {
566 return !(this->operator==(x));
567 }
568
569
570 Boolean CQLValueRep::operator<=(const CQLValueRep& x)
571 {
572 if (this->operator<(x) || this->operator==(x))
573 {
574 return true;
575 }
576
577 return false;
578 chuck 1.2 }
579
580
581 Boolean CQLValueRep::operator>=(const CQLValueRep& x)
582 {
583 _validate(x);
584
585 return !(this->operator<(x));
586 }
587
588
589 Boolean CQLValueRep::operator<(const CQLValueRep& x)
590 {
591 PEG_METHOD_ENTER(TRC_CQL, "CQLValueRep::operator<");
592
593 Uint64 tmpU64;
594 Sint64 tmpS64;
595 Real64 tmpR64;
|
596 humberto 1.16
597 _validate(x);
598
599 if(_theValue.isNull() && x._theValue.isNull())
600 {
601 return true;
602 }
603 if(_theValue.isNull() || x._theValue.isNull())
604 {
605 return false;
606 }
607 if(_theValue.isArray() || x._theValue.isArray())
608 {
609 return false;
610 }
|
611 chuck 1.2
612 switch(_valueType)
613 {
614 case CQLValue::Null_type:
615 {
616 return false;
617 }
618 break;
619
620 case CQLValue::Sint64_type:
621 {
622 _theValue.get(tmpS64);
623 if(x._valueType == CQLValue::Sint64_type)
624 {
625 Sint64 right;
626 x._theValue.get(right);
627
628 return tmpS64 < right;
629 }
630 else if(x._valueType == CQLValue::Uint64_type)
631 {
632 chuck 1.2 x._theValue.get(tmpU64);
633
634 if(tmpU64 > (Uint64)PEGASUS_SINT64_MIN)
635 {
636 return true;
637 }
638 else
639 {
640 return tmpS64 < (Sint64)tmpU64;
641 }
642 }
643 else
644 {
645 x._theValue.get(tmpR64);
646
647 return tmpS64 < tmpR64;
648 }
649 break;
650 }
651 case CQLValue::Uint64_type:
652 {
653 chuck 1.2 _theValue.get(tmpU64);
654 if(x._valueType == CQLValue::Uint64_type)
655 {
656 Uint64 right;
657 x._theValue.get(right);
658
659 return tmpU64 < right;
660 }
661 else if(x._valueType == CQLValue::Sint64_type)
662 {
663 x._theValue.get(tmpS64);
664
665 if(tmpU64 > (Uint64)PEGASUS_SINT64_MIN)
666 {
667 return false;
668 }
669 else
670 {
671 return (Sint64)tmpU64 < tmpS64;
672 }
673 }
674 chuck 1.2 else
675 {
676 x._theValue.get(tmpR64);
677 if(tmpU64 > (Uint64)PEGASUS_SINT64_MIN)
678 {
679 return false;
680 }
681 else
682 {
683 return (Sint64)tmpU64 < tmpR64;
684 }
685 }
686 break;
687 }
688 case CQLValue::Real_type:
689 {
690 _theValue.get(tmpR64);
691 if(x._valueType == CQLValue::Real_type)
692 {
693 Real64 right;
694 x._theValue.get(right);
695 chuck 1.2
696 return tmpR64 < right;
697 }
698 else if(x._valueType == CQLValue::Uint64_type)
699 {
700 x._theValue.get(tmpU64);
701
702 if(tmpU64 > (Uint64)PEGASUS_SINT64_MIN)
703 {
704 return true;
705 }
706 else
707 {
708 return tmpR64 < (Sint64)tmpU64;
709 }
710 }
711 else
712 {
713 x._theValue.get(tmpS64);
714
715 return tmpR64 < tmpS64;
716 chuck 1.2 }
717 break;
718 }
719 case CQLValue::String_type:
720 {
721 String tmpS1;
722 String tmpS2;
723 _theValue.get(tmpS1);
724 x._theValue.get(tmpS2);
725 return tmpS1 < tmpS2;
726 }
727 break;
728 case CQLValue::CIMDateTime_type:
729 {
730 CIMDateTime tmpS1;
731 CIMDateTime tmpS2;
732 _theValue.get(tmpS1);
733 x._theValue.get(tmpS2);
|
734 david 1.14 return tmpS1 < tmpS2;
|
735 chuck 1.2 }
736 break;
737
738 default:
739 MessageLoaderParms mload(String("CQL.CQLValueRep.CONSTRUCTOR_FAILURE"),
|
740 humberto 1.16 String("Undefined case:$0 in constructor."));
|
741 chuck 1.2 throw CQLRuntimeException(mload);
742 break;
743 }
744 PEG_METHOD_EXIT();
745 return false;
746 }
747
748
749 Boolean CQLValueRep::operator>(const CQLValueRep& x)
750 {
751 _validate(x);
752
753 if (this->operator<(x) || this->operator==(x))
754 {
755 return false;
756 }
757 return true;
758 }
759
760
761 CQLValueRep CQLValueRep::operator+(const CQLValueRep x)
762 chuck 1.2 {
763 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::operator+");
764 _validate(x);
765
766 switch(_valueType)
767 {
768 case CQLValue::String_type:
769 {
770 String tmpS1;
771 String tmpS2;
772 _theValue.get(tmpS1);
773 x._theValue.get(tmpS2);
774 return CQLValueRep(tmpS1 + tmpS2);
775 }
776 break;
777
778 default:
779 MessageLoaderParms mload(String("CQL.CQLValueRep.CONSTRUCTOR_FAILURE"),
|
780 humberto 1.16 String("Undefined case:$0 in constructor."),
781 _valueType);
|
782 chuck 1.2 throw CQLRuntimeException(mload);
783 break;
784 }
785
786 PEG_METHOD_EXIT();
787 return x;
788 }
789
790 CQLValue::CQLValueType CQLValueRep::getValueType()
791 {
792 return _valueType;
793 }
794
795
796 void CQLValueRep::setNull()
797 {
798 _valueType = CQLValue::Null_type;
799 _isResolved = true;
800 }
801
802
803 chuck 1.2 Boolean CQLValueRep::isResolved()
804 {
805 return _isResolved;
806 }
807
808
809 Boolean CQLValueRep::isNull()
810 {
811 if(_valueType == CQLValue::Null_type)
812 {
813 return true;
814 }
815 return false;
816 }
817
818
819 Boolean CQLValueRep::isa(const CQLChainedIdentifier& inID,QueryContext& QueryCtx)
|
820 david 1.11 {
|
821 chuck 1.2 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::isa()");
|
822 david 1.11 if(!_isResolved ||
823 (_valueType != CQLValue::CIMObject_type))
824 {
825 MessageLoaderParms mload(String("CQL.CQLValueRep.ISA_TYPE_MISMATCH"),
|
826 humberto 1.16 String("The type: $0 is not an object, or the object is not resolved"),
827 _valueType);
|
828 david 1.11 throw CQLRuntimeException(mload);
829 }
830
831 CIMName className;
832 CIMName isaName;
833 CIMObject obj;
834
835 _theValue.get(obj);
836
837 className = obj.getClassName();
838 isaName = inID[0].getName();
839
|
840 humberto 1.16 // Short circuit if the Object name and the isa name are the same.
841 // This will prevent an unneeded repository call.
842 if(className == isaName)
843 {
844 return true;
845 }
|
846 david 1.11 Array<CIMName> cimNames = QueryCtx.enumerateClassNames(isaName);
847 cimNames.append(isaName);
|
848 chuck 1.2
|
849 david 1.11 for(Uint32 i = 0; i < cimNames.size() ; ++i)
850 {
851
852 if(cimNames[i] == className)
853 {
854 PEG_METHOD_EXIT();
855 return true;
856 }
857 }
858 PEG_METHOD_EXIT();
859 return false;
|
860 chuck 1.2 }
861
862
863 Boolean CQLValueRep::like(const CQLValueRep& inVal)
864 {
865 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::like()");
866 if( _valueType != CQLValue::String_type ||
867 inVal._valueType != CQLValue::String_type)
868 {
869 MessageLoaderParms mload(String("CQL.CQLValueRep.LIKE_TYPE_MISMATCH"),
|
870 humberto 1.16 String("The following types may not be strings:$0,$1."),
871 _valueType,inVal._valueType);
|
872 chuck 1.2 throw CQLRuntimeException(mload);
873 }
874
875 String leftside;
876 _theValue.get(leftside);
877
878 String rightside;
879 inVal._theValue.get(rightside);
880
881 CQLRegularExpression re;
882
883 PEG_METHOD_EXIT();
884 return re.match(leftside,rightside);
885
886 }
887
888 CQLChainedIdentifier CQLValueRep::getChainedIdentifier()const
889 {
890 return _CQLChainId;
891 }
892
893 chuck 1.2 Uint64 CQLValueRep::getUint()const
894 {
895 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getUint()");
896 if(_valueType != CQLValue::Uint64_type)
897 {
|
898 humberto 1.16 String str;
899 if(_theValue.isArray())
900 str = "array";
901 else str = valueTypeToString(_valueType);
|
902 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
903 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
904 str,
905 String("getUint"));
|
906 chuck 1.2 throw CQLRuntimeException(mload);
907 }
908 Uint64 tmp;
909 _theValue.get(tmp);
910
911 PEG_METHOD_EXIT();
912 return tmp;
913 }
914
915 Boolean CQLValueRep::getBool()const
916 {
917 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getBool()");
918 if(_valueType != CQLValue::Boolean_type)
919 {
|
920 humberto 1.16 String str;
921 if(_theValue.isArray())
922 str = "array";
923 else str = valueTypeToString(_valueType);
|
924 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
925 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
926 str,
927 String("getBool"));
|
928 chuck 1.2 throw CQLRuntimeException(mload);
929 }
930 Boolean tmp;
931 _theValue.get(tmp);
932
933 PEG_METHOD_EXIT();
934 return tmp;
935 }
936
937 Sint64 CQLValueRep::getSint()const
938 {
939 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getSint()");
940
941 if(_valueType != CQLValue::Sint64_type)
942 {
|
943 humberto 1.16 String str;
944 if(_theValue.isArray())
945 str = "array";
946 else str = valueTypeToString(_valueType);
|
947 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
948 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
949 str,
950 String("getSint"));
|
951 chuck 1.2 throw CQLRuntimeException(mload);
952 }
953 Sint64 tmp;
954 _theValue.get(tmp);
955
956 PEG_METHOD_EXIT();
957 return tmp;
958 }
959
960 Real64 CQLValueRep::getReal()const
961 {
962 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getReal()");
963 if(_valueType != CQLValue::Real_type)
964 {
|
965 humberto 1.16 String str;
966 if(_theValue.isArray())
967 str = "array";
968 else str = valueTypeToString(_valueType);
|
969 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
970 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
971 str,
972 String("getReal"));
|
973 chuck 1.2 throw CQLRuntimeException(mload);
974 }
975 Real64 tmp;
976 _theValue.get(tmp);
977 PEG_METHOD_EXIT();
978 return tmp;
979 }
980
981 String CQLValueRep::getString()const
982 {
983 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getString()");
984 if(_valueType != CQLValue::String_type)
985 {
|
986 humberto 1.16 String str;
987 if(_theValue.isArray())
988 str = "array";
989 else str = valueTypeToString(_valueType);
|
990 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
991 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
992 str,
993 String("getString"));
|
994 chuck 1.2 throw CQLRuntimeException(mload);
995 }
996 String tmp;
997 _theValue.get(tmp);
998 PEG_METHOD_EXIT();
999 return tmp;
1000 }
1001
1002 CIMDateTime CQLValueRep::getDateTime()const
1003 {
1004 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getDateTime()");
1005 if(_valueType != CQLValue::CIMDateTime_type)
1006 {
|
1007 humberto 1.16 String str;
1008 if(_theValue.isArray())
1009 str = "array";
1010 else str = valueTypeToString(_valueType);
|
1011 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
1012 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
1013 str,
1014 String("getDateTime"));
|
1015 chuck 1.2 throw CQLRuntimeException(mload);
1016 }
1017 CIMDateTime tmp;
1018 _theValue.get(tmp);
1019 PEG_METHOD_EXIT();
1020 return tmp;
1021 }
1022
1023 CIMObjectPath CQLValueRep::getReference()const
1024 {
1025 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getReference()");
1026
1027 if(_valueType != CQLValue::CIMReference_type)
1028 {
|
1029 humberto 1.16 String str;
1030 if(_theValue.isArray())
1031 str = "array";
1032 else str = valueTypeToString(_valueType);
|
1033 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
1034 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
1035 str,
1036 String("getReference"));
|
1037 chuck 1.2 throw CQLRuntimeException(mload);
1038 }
1039 CIMObjectPath tmp;
1040 _theValue.get(tmp);
1041
1042 PEG_METHOD_EXIT();
1043 return tmp;
1044 }
1045
1046 CIMObject CQLValueRep::getObject()const
1047 {
1048 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::getObject()");
1049 if(_valueType != CQLValue::CIMObject_type)
1050 {
|
1051 humberto 1.16 String str;
1052 if(_theValue.isArray())
1053 str = "array";
1054 else str = valueTypeToString(_valueType);
|
1055 chuck 1.2 MessageLoaderParms mload(String("CQL.CQLValueRep.TYPE_MISMATCH"),
|
1056 humberto 1.16 String("The type: $0 is not correct for $1 operation."),
1057 str,
1058 String("getObject"));
|
1059 chuck 1.2 throw CQLRuntimeException(mload);
1060 }
1061 CIMObject tmp;
|
1062 david 1.5 _theValue.get(tmp);
|
1063 chuck 1.2 PEG_METHOD_EXIT();
1064 return tmp.clone();
1065 }
1066
1067 String CQLValueRep::toString()const
1068 {
1069 if(_valueType == CQLValue::CQLIdentifier_type)
1070 {
1071 return _CQLChainId.toString();
1072 }
1073 else
|
1074 lucier 1.10 {
1075 String returnStr;
1076 if (_valueType == CQLValue::String_type)
|
1077 chuck 1.2 {
|
1078 lucier 1.10 returnStr.append("'");
|
1079 chuck 1.2 }
|
1080 lucier 1.15
1081 String temp(_theValue.toString());
1082
1083 // If the string is a real string, then strip padding off the exponent
1084 if (_valueType == CQLValue::Real_type)
1085 temp = CQLUtilities::formatRealStringExponent(temp);
1086
1087 returnStr.append(temp);
|
1088 lucier 1.10
1089 if (_valueType == CQLValue::String_type)
1090 {
1091 returnStr.append("'");
1092 }
1093 return returnStr;
1094 }
|
1095 chuck 1.2 }
1096
1097
1098
1099 void CQLValueRep::_validate(const CQLValueRep& x)
1100 {
1101 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::_validate()");
|
1102 humberto 1.16
1103 // Do not allow an array value be compared to a non array value.
1104 if(x._theValue.isArray() != _theValue.isArray())
1105 {
1106 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1107 String("Validation type mismatch error for type: $0"),
1108 String("ARRAY"));
1109 throw CQLRuntimeException(mload);
1110 }
|
1111 chuck 1.2
|
1112 humberto 1.16 switch(_valueType)
1113 {
1114 case CQLValue::Boolean_type:
1115 if(x._valueType != CQLValue::Boolean_type)
1116 {
1117 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1118 String("Validation type mismatch error for type: $0"),
1119 String("BOOLEAN"));
1120 throw CQLRuntimeException(mload);
1121 }
1122 break;
1123 case CQLValue::Sint64_type:
1124 case CQLValue::Uint64_type:
1125 case CQLValue::Real_type:
1126 if(x._valueType != CQLValue::Sint64_type &&
1127 x._valueType != CQLValue::Uint64_type &&
1128 x._valueType != CQLValue::Real_type)
1129 {
1130 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1131 String("Validation type mismatch error for type: $0"),
1132 String("SINT64, UINT64, REAL64"));
1133 humberto 1.16 throw CQLRuntimeException(mload);
1134 }
1135 break;
1136 case CQLValue::String_type:
1137 if(x._valueType != CQLValue::String_type)
1138 {
1139 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1140 String("Validation type mismatch error for type: $0"),
1141 String("STIRNG"));
1142 throw CQLRuntimeException(mload);
1143 }
1144 break;
1145 case CQLValue::CIMDateTime_type:
1146 if(x._valueType != CQLValue::CIMDateTime_type)
1147 {
1148 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1149 String("Validation type mismatch error for type: $0"),
1150 String("CIMDATETIME"));
1151 throw CQLRuntimeException(mload);
1152 }
1153 break;
1154 humberto 1.16 case CQLValue::CIMReference_type:
1155 if(x._valueType != CQLValue::CIMReference_type)
1156 {
1157 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1158 String("Validation type mismatch error for type: $0"),
1159 String("CIMREFERENCE"));
1160 throw CQLRuntimeException(mload);
1161 }
1162 break;
1163 case CQLValue::CIMObject_type:
1164 if(x._valueType != CQLValue::CIMObject_type)
1165 {
1166 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1167 String("Validation type mismatch error for type: $0"),
1168 String("CIMOBJECT"));
1169 throw CQLRuntimeException(mload);
1170 }
1171 break;
1172 case CQLValue::CQLIdentifier_type:
1173 if(x._valueType != CQLValue::CQLIdentifier_type)
1174 {
1175 humberto 1.16 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1176 String("Validation type mismatch error for type: $0"),
1177 String("CQLIDENTIFIER"));
1178 throw CQLRuntimeException(mload);
1179 }
1180 break;
1181
1182 default:
1183 MessageLoaderParms mload(String("CQL.CQLValueRep.OP_TYPE_MISMATCH"),
1184 String("Validation type mismatch error for type: $0"),
1185 String("UNKNOWN"));
1186 throw CQLRuntimeException(mload);
1187 break;
1188 }
1189 PEG_METHOD_EXIT();
1190 return;
|
1191 chuck 1.2 }
1192
|
1193 david 1.3 void CQLValueRep::_setValue(CIMValue cv,Sint64 key)
|
1194 chuck 1.2 {
1195 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::_setValue()");
1196 CIMValue tmp;
|
1197 kumpf 1.23 Uint32 index = 0;
|
1198 david 1.3
|
1199 humberto 1.16 if(cv.isNull())
1200 {
1201 _valueType = CQLValue::Null_type;
1202 }
|
1203 david 1.3 if(key != -1)
1204 {
1205 index = (Uint32)key;
1206 }
|
1207 chuck 1.2 if(cv.isArray())
1208 {
1209 switch(cv.getType())
1210 {
1211 case CIMTYPE_BOOLEAN:
1212 {
|
1213 david 1.3 if(key == -1)
|
1214 chuck 1.2 {
1215 _theValue = cv;
1216 }
1217 else
1218 {
1219 Array<Boolean> _bool;
1220 cv.get(_bool);
1221 _theValue.set(_bool[index]);
1222 }
1223
1224 _valueType = CQLValue::Boolean_type;
1225 break;
1226 }
1227 case CIMTYPE_UINT8:
1228 {
1229 Array<Uint8> _uint;
1230 cv.get(_uint);
1231
|
1232 david 1.3 if(key == -1)
|
1233 chuck 1.2 {
1234 Array<Uint64> _uint64;
1235 for(Uint32 i = 0; i < _uint.size(); ++i)
1236 {
1237 _uint64.append((Uint64)_uint[i]);
1238 }
1239 _theValue = CIMValue(_uint64);
1240 }
1241 else
1242 {
1243 _theValue.set((Uint64)_uint[index]);
1244 }
1245 _valueType = CQLValue::Uint64_type;
1246 break;
1247 }
1248 case CIMTYPE_UINT16:
1249 {
1250 Array<Uint16> _uint;
1251 cv.get(_uint);
1252
|
1253 david 1.3 if(key == -1)
|
1254 chuck 1.2 {
1255 Array<Uint64> _uint64;
1256 for(Uint32 i = 0; i < _uint.size(); ++i)
1257 {
1258 _uint64.append((Uint64)_uint[i]);
1259 }
1260 _theValue = CIMValue(_uint64);
1261 }
1262 else
1263 {
1264 _theValue.set((Uint64)_uint[index]);
1265 }
1266 _valueType = CQLValue::Uint64_type;
1267 break;
1268 }
1269 case CIMTYPE_UINT32:
1270 {
1271 Array<Uint32> _uint;
1272 cv.get(_uint);
1273
|
1274 david 1.3 if(key == -1)
|
1275 chuck 1.2 {
1276 Array<Uint64> _uint64;
1277 for(Uint32 i = 0; i < _uint.size(); ++i)
1278 {
1279 _uint64.append((Uint64)_uint[i]);
1280 }
1281 _theValue = CIMValue(_uint64);
1282 }
1283 else
1284 {
1285 _theValue.set((Uint64)_uint[index]);
1286 }
1287 _valueType = CQLValue::Uint64_type;
1288 break;
1289 }
1290 case CIMTYPE_UINT64:
1291 {
|
1292 david 1.3 if(key == -1)
|
1293 chuck 1.2 {
1294 _theValue = cv;
1295 }
1296 else
1297 {
1298 Array<Uint64> _uint;
1299 cv.get(_uint);
1300 _theValue.set((Uint64)_uint[index]);
1301 }
1302 _valueType = CQLValue::Uint64_type;
1303 break;
1304 }
1305 case CIMTYPE_SINT8:
1306 {
1307 Array<Sint8> _sint;
1308 cv.get(_sint);
1309
|
1310 david 1.3 if(key == -1)
|
1311 chuck 1.2 {
1312 Array<Sint64> _sint64;
1313 for(Uint32 i = 0; i < _sint.size(); ++i)
1314 {
1315 _sint64.append((Sint64)_sint[i]);
1316 }
1317 _theValue = CIMValue(_sint64);
1318 }
1319 else
1320 {
1321 _theValue.set((Sint64)_sint[index]);
1322 }
1323 _valueType = CQLValue::Sint64_type;
1324 break;
1325 }
1326 case CIMTYPE_SINT16:
1327 {
1328 Array<Sint16> _sint;
1329 cv.get(_sint);
1330
|
1331 david 1.3 if(key == -1)
|
1332 chuck 1.2 {
1333 Array<Sint64> _sint64;
1334 for(Uint32 i = 0; i < _sint.size(); ++i)
1335 {
1336 _sint64.append((Sint64)_sint[i]);
1337 }
1338 _theValue = CIMValue(_sint64);
1339 }
1340 else
1341 {
1342 _theValue.set((Sint64)_sint[index]);
1343 }
1344 _valueType = CQLValue::Sint64_type;
1345 break;
1346 }
1347 case CIMTYPE_SINT32:
1348 {
1349 Array<Sint32> _sint;
1350 cv.get(_sint);
1351
|
1352 david 1.3 if(key == -1)
|
1353 chuck 1.2 {
1354 Array<Sint64> _sint64;
1355 for(Uint32 i = 0; i < _sint.size(); ++i)
1356 {
1357 _sint64.append((Sint64)_sint[i]);
1358 }
1359 _theValue = CIMValue(_sint64);
1360 }
1361 else
1362 {
1363 _theValue.set((Sint64)_sint[index]);
1364 }
1365 _valueType = CQLValue::Sint64_type;
1366 break;
1367 }
1368 case CIMTYPE_SINT64:
1369 {
|
1370 david 1.3 if(key == -1)
|
1371 chuck 1.2 {
1372 _theValue = cv;
1373 }
1374 else
1375 {
1376 Array<Sint64> _sint;
1377 cv.get(_sint);
1378 _theValue.set((Sint64)_sint[index]);
1379 }
1380 _valueType = CQLValue::Sint64_type;
1381 break;
1382 }
1383
1384 case CIMTYPE_REAL32:
1385 {
1386 Array<Real32> _real;
1387 cv.get(_real);
1388
|
1389 david 1.3 if(key == -1)
|
1390 chuck 1.2 {
1391 Array<Real64> _real64;
1392 for(Uint32 i = 0; i < _real.size(); ++i)
1393 {
1394 _real64.append((Real64)_real[i]);
1395 }
1396 _theValue = CIMValue(_real64);
1397 }
1398 else
1399 {
1400 _theValue.set((Real64)_real[index]);
1401 }
1402 _valueType = CQLValue::Real_type;
1403 break;
1404 }
1405 case CIMTYPE_REAL64:
1406 {
|
1407 david 1.3 if(key == -1)
|
1408 chuck 1.2 {
1409 _theValue = cv;
1410 }
1411 else
1412 {
1413 Array<Real64> _real;
1414 cv.get(_real);
1415 _theValue.set((Real64)_real[index]);
1416 }
1417 _valueType = CQLValue::Real_type;
1418 break;
1419 }
1420 case CIMTYPE_CHAR16:
1421 {
1422 Array<Char16> _str16;
1423 cv.get(_str16);
1424
|
1425 chuck 1.13 Char16 _tmp[2];
1426
|
1427 david 1.3 if(key == -1)
|
1428 chuck 1.13 {
1429 Array<String> _str;
1430 for(Uint32 i = 0; i < _str16.size(); ++i)
1431 {
1432 _tmp[0] = _str16[i];
1433 _tmp[1] = '\0';
1434 _str.append(String(_tmp));
1435 }
1436 _theValue = CIMValue(_str);
1437 }
|
1438 chuck 1.2 else
|
1439 chuck 1.13 {
1440 _tmp[0] = _str16[index];
1441 _tmp[1] = '\0';
1442 _theValue.set(String(_tmp));
1443 }
|
1444 chuck 1.2 _valueType = CQLValue::String_type;
|
1445 chuck 1.13 break;
|
1446 chuck 1.2 }
1447 case CIMTYPE_STRING:
1448 {
|
1449 david 1.3 if(key == -1)
|
1450 chuck 1.2 {
1451 _theValue = cv;
1452 }
1453 else
1454 {
1455 Array<String> _str;
1456 cv.get(_str);
1457 _theValue.set(_str[index]);
1458 }
1459 _valueType = CQLValue::String_type;
1460 break;
1461 }
1462 case CIMTYPE_DATETIME:
1463 {
|
1464 david 1.3 if(key == -1)
|
1465 chuck 1.2 {
1466 _theValue = cv;
1467 }
1468 else
1469 {
1470 Array<CIMDateTime> _date;
1471 cv.get(_date);
1472 _theValue.set(_date[index]);
1473 }
1474 _valueType = CQLValue::CIMDateTime_type;
1475 break;
1476 }
1477 case CIMTYPE_REFERENCE:
1478 {
|
1479 david 1.3 if(key == -1)
|
1480 chuck 1.2 {
1481 _theValue = cv;
1482 }
1483 else
1484 {
1485 Array<CIMObjectPath> _path;
1486 cv.get(_path);
1487 _theValue.set(_path[index]);
1488 }
1489 _valueType = CQLValue::CIMReference_type;
1490 break;
1491 }
|
1492 david 1.8 case CIMTYPE_OBJECT:
|
1493 chuck 1.2 {
|
1494 david 1.3 if(key == -1)
|
1495 chuck 1.2 {
1496 _theValue = cv;
1497 }
1498 else
1499 {
1500 Array<CIMObject> _obj;
1501 cv.get(_obj);
1502 _theValue.set(_obj[index]);
1503 }
1504 _valueType = CQLValue::CIMObject_type;
1505 break;
|
1506 david 1.5 }
|
1507 chuck 1.2 default:
1508 MessageLoaderParms mload(String("CQL.CQLValueRep.SET_VALUE"),
|
1509 humberto 1.16 String("Unable to set internal object type: $0."),
1510 cv.getType());
|
1511 chuck 1.2 throw CQLRuntimeException(mload);
1512 } // switch statement
1513 }
1514 else
1515 {
1516 switch(cv.getType())
1517 {
1518 case CIMTYPE_BOOLEAN:
1519 {
1520 _theValue = cv;
1521 _valueType = CQLValue::Boolean_type;
1522 break;
1523 }
1524 case CIMTYPE_UINT8:
1525 {
1526 Uint8 _tmp;
1527 cv.get(_tmp);
1528 _theValue = CIMValue((Uint64)_tmp);
1529 _valueType = CQLValue::Uint64_type;
1530 break;
1531 }
1532 chuck 1.2 case CIMTYPE_UINT16:
1533 {
1534 Uint16 _tmp;
1535 cv.get(_tmp);
1536 _theValue = CIMValue((Uint64)_tmp);
1537 _valueType = CQLValue::Uint64_type;
1538 break;
1539 }
1540 case CIMTYPE_UINT32:
1541 {
1542 Uint32 _tmp;
1543 cv.get(_tmp);
1544 _theValue = CIMValue((Uint64)_tmp);
1545 _valueType = CQLValue::Uint64_type;
1546 break;
1547 }
1548 case CIMTYPE_UINT64:
1549 {
1550 Uint64 _tmp;
1551 cv.get(_tmp);
1552 _theValue = CIMValue((Uint64)_tmp);
1553 chuck 1.2 _valueType = CQLValue::Uint64_type;
1554 break;
1555 }
1556 case CIMTYPE_SINT8:
1557 {
1558 Sint8 _tmp;
1559 cv.get(_tmp);
1560 _theValue = CIMValue((Sint64)_tmp);
1561 _valueType = CQLValue::Sint64_type;
1562 break;
1563 }
1564 case CIMTYPE_SINT16:
1565 {
1566 Sint16 _tmp;
1567 cv.get(_tmp);
1568 _theValue = CIMValue((Sint64)_tmp);
1569 _valueType = CQLValue::Sint64_type;
1570 break;
1571 }
1572 case CIMTYPE_SINT32:
1573 {
1574 chuck 1.2 Sint32 _tmp;
1575 cv.get(_tmp);
1576 _theValue = CIMValue((Sint64)_tmp);
1577 _valueType = CQLValue::Sint64_type;
1578 break;
1579 }
1580 case CIMTYPE_SINT64:
1581 {
1582 Sint64 _tmp;
1583 cv.get(_tmp);
1584 _theValue = CIMValue((Sint64)_tmp);
1585 _valueType = CQLValue::Sint64_type;
1586 break;
1587 }
1588 case CIMTYPE_REAL32:
1589 {
1590 Real32 _tmp;
1591 cv.get(_tmp);
1592 _theValue = CIMValue((Real64)_tmp);
1593 _valueType = CQLValue::Real_type;
1594 break;
1595 chuck 1.2 }
1596 case CIMTYPE_REAL64:
1597 {
1598 Real64 _tmp;
1599 cv.get(_tmp);
1600 _theValue = CIMValue((Real64)_tmp);
1601 _valueType = CQLValue::Real_type;
1602 break;
1603 }
1604 case CIMTYPE_CHAR16:
1605 {
|
1606 chuck 1.13 Char16 _tmp[2];
1607 cv.get(_tmp[0]);
1608 _tmp[1] = '\0';
1609 _theValue = CIMValue(String(_tmp));
|
1610 chuck 1.2 _valueType = CQLValue::String_type;
1611 break;
1612 }
1613 case CIMTYPE_STRING:
1614 {
1615 _theValue = cv;
1616 _valueType = CQLValue::String_type;
1617 break;
1618 }
1619 case CIMTYPE_DATETIME:
1620 {
1621 _theValue = cv;
1622 _valueType = CQLValue::CIMDateTime_type;
1623 break;
1624 }
1625 case CIMTYPE_REFERENCE:
1626 {
1627 _theValue = cv;
1628 _valueType = CQLValue::CIMReference_type;
1629 break;
1630 }
|
1631 david 1.8 case CIMTYPE_OBJECT:
|
1632 chuck 1.2 {
1633 _theValue = cv;
1634 _valueType = CQLValue::CIMObject_type;
1635 break;
1636 }
1637 default:
1638 MessageLoaderParms mload(String("CQL.CQLValueRep.SET_VALUE"),
|
1639 humberto 1.16 String("Unable to set internal object type: $0."),
1640 cv.getType());
|
1641 chuck 1.2 throw CQLRuntimeException(mload);
1642 }
1643
1644 }
1645
1646 _isResolved = true;
1647
1648 PEG_METHOD_EXIT();
1649 return;
1650 }
1651
|
1652 vijay.eli 1.22 void CQLValueRep::applyContext(const QueryContext& _ctx,
1653 const CQLChainedIdentifier& inCid)
|
1654 chuck 1.2 {
1655 if(inCid.size() != 0 && _CQLChainId.size() == 1)
1656 {
1657 // If we get here we have a stand alone Symbolic constant.
1658 // We need to take the chain and create a complete context
1659 // for the symbolic constant. We will use the context from
1660 // inCid to populate the context for chain.
1661 /*
1662 _CQLChainId[0].setName(inCid[inCid.size()-1].getName());
1663 _CQLChainId[0].applyScope(inCid[inCid.size()-1].getScope());
1664 */
1665
1666 CQLIdentifier id = _CQLChainId[0];
1667 id.setName(inCid[inCid.size()-1].getName());
1668 id.applyScope(inCid[inCid.size()-1].getScope());
1669
1670 CQLChainedIdentifier chainId(id);
1671
1672 for(Sint32 i = inCid.size()-2; i >= 0; --i)
1673 {
1674 chainId.prepend(inCid[i]);
1675 chuck 1.2 }
1676
1677 _CQLChainId = chainId;
1678
1679
1680 CIMInstance temp;
1681 resolve(temp,_ctx);
1682 }
1683 else
1684 {
|
1685 vijay.eli 1.22 _CQLChainId.applyContext(const_cast<QueryContext&>(_ctx));
|
1686 chuck 1.2 }
1687
1688 // Add the chained identifier to the WHERE identifier list.
1689 // Note: CQLValue's are only used in WHERE processing.
1690 if (_CQLChainId.size() > 0)
1691 {
|
1692 vijay.eli 1.22 const_cast<QueryContext&>(_ctx).addWhereIdentifier(_CQLChainId);
|
1693 chuck 1.2 }
1694 }
1695
1696 void CQLValueRep::_resolveSymbolicConstant(const QueryContext& inQueryCtx)
1697 {
1698 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::_resolveSymbolicConstant()");
1699
1700 Array<String> valueMapArray; // Value Map Qualifier for property
1701 Array<String> valuesArray; // Values Qualifier for property
1702 CIMName className;
1703 CQLIdentifier lid = _CQLChainId.getLastIdentifier();
1704 CIMClass QueryClass;
1705 CIMValue valueMap; // CIMValue for Value Map Qualifiers
1706 CIMValue values; // CIMValue for Values Qualifiers
1707 Boolean matchFound = false; // Indicator for match Qualifier
|
1708 kumpf 1.23 Uint32 matchIndex = 0; // Placeholder for matched Qualifier
|
1709 chuck 1.2
1710 if(lid.isScoped())
1711 {
1712 className = lid.getScope();
1713 }
1714 else
1715 {
1716 className = _CQLChainId[0].getName();
1717 }
1718
1719 QueryClass = inQueryCtx.getClass(className);
1720
1721 Uint32 propertyIndex =
1722 QueryClass.findProperty(lid.getName());
1723
1724 if(propertyIndex == PEG_NOT_FOUND)
1725 {
1726 MessageLoaderParms mload(String("CQL.CQLValueRep.PROP_NOT_FOUND"),
1727 String("Property $0 not found on class $1."),
1728 lid.getName().getString(),
1729 className.getString());
1730 chuck 1.2 throw CQLRuntimeException(mload);
1731 }
1732
1733 CIMProperty queryPropObj = QueryClass.getProperty(propertyIndex);
1734
1735 // We have a symbolic constant (ex. propName#OK)
1736 // We need to retrieve the ValueMap and Values Qualifiers for
1737 // the property if the exist.
|
1738 humberto 1.16 Uint32 qualIndex = queryPropObj.findQualifier(CIMName("Values"));
|
1739 chuck 1.2
1740 if(qualIndex == PEG_NOT_FOUND)
1741 {
1742 // This property can not be processed with a symbolic constant.
1743 MessageLoaderParms mload(String("CQL.CQLValueRep.QUALIFIER_NOT_FOUND"),
1744 String("Qualifier $0 not found on Property $1 in class $2."),
|
1745 humberto 1.16 String("Values"),
|
1746 chuck 1.2 lid.getName().getString(),
1747 className.getString());
1748 throw CQLRuntimeException(mload);
1749 }
1750
|
1751 humberto 1.16 values = queryPropObj.getQualifier(qualIndex).getValue();
|
1752 david 1.11
|
1753 humberto 1.16 qualIndex = queryPropObj.findQualifier(CIMName("ValueMap"));
|
1754 chuck 1.2
1755 if(qualIndex == PEG_NOT_FOUND)
1756 {
|
1757 humberto 1.16 // This property does not have a ValueMap Qualifier,
1758 // therefore the values must be the list of symbolic constants.
|
1759 chuck 1.2
|
1760 humberto 1.16 values.get(valuesArray);
|
1761 chuck 1.2
1762 // We will loop through the list of Symbolic constants to
1763 // determine if we have a match with the Symbolic constant
1764 // defined in the CQLIdentifier.
|
1765 humberto 1.16 for(Uint32 i = 0; i < valuesArray.size(); ++i)
|
1766 chuck 1.2 {
|
1767 humberto 1.16 if(String::equalNoCase(valuesArray[i],lid.getSymbolicConstantName()))
|
1768 chuck 1.2 {
1769 matchFound = true;
1770 matchIndex = i;
1771 break;
1772 }
1773 }
1774 if(matchFound == false)
1775 {
1776 // The symbolic constant provided is not valid
1777 // for this property.
1778 MessageLoaderParms mload(String("CQL.CQLValueRep.INVALID_SYMBOLIC_CONSTANT"),
1779 String("Provided symbolic constant $0 is not valid for property $1 in class $2."),
1780 lid.getSymbolicConstantName(),
1781 lid.getName().getString(),
1782 className.getString());
1783 throw CQLRuntimeException(mload);
1784 }
1785
1786 // The symbolic constant defined in the CQLIdentifier is
1787 // valid for this property. Now we need to set the value.
1788 // Set primitive
|
1789 humberto 1.16 _setValue(Uint64(matchIndex));
|
1790 chuck 1.2
1791 PEG_METHOD_EXIT();
1792 return;
1793 }
1794 else
1795 {
1796 // The qualifier Values is defined for the property.
1797 // valueMap must be a list of #'s.
1798
|
1799 humberto 1.16 valueMap = queryPropObj.getQualifier(qualIndex).getValue();
|
1800 chuck 1.2
1801 valueMap.get(valueMapArray);
1802 values.get(valuesArray);
1803
1804 // We will loop through the list of Symbolic constants to
1805 // determine if we have a match with the Symbolic constant
1806 // defined in the CQLIdentifier.
1807 for(Uint32 i = 0; i < valuesArray.size(); ++i)
1808 {
1809 if(String::equalNoCase(valuesArray[i],lid.getSymbolicConstantName()))
1810 {
1811 matchFound = true;
1812 matchIndex = i;
1813 break;
1814 }
1815 }
1816 if(matchFound == false)
1817 {
1818 // The symbolic constant provided is not valid
1819 // for this property.
1820 MessageLoaderParms mload(String("CQL.CQLValueRep.INVALID_SYMBOLIC_CONSTANT"),
1821 chuck 1.2 String("Provided symbolic constant $0 is not valid for property $1 in class $2."),
1822 lid.getSymbolicConstantName(),
1823 lid.getName().getString(),
1824 className.getString());
1825 throw CQLRuntimeException(mload);
1826 }
1827
|
1828 humberto 1.16 // Set Primitive
1829
1830 if(valueMapArray[matchIndex].find(String("..")) != PEG_NOT_FOUND)
1831 {
1832 // The symbolic constant provided is not valid
1833 // for this property.
1834 MessageLoaderParms mload(String("CQL.CQLValueRep.INVALID_SYMBOLIC_CONSTANT"),
1835 String("Provided symbolic constant $0 is not valid for property $1 in class $2."),
1836 lid.getSymbolicConstantName(),
1837 lid.getName().getString(),
1838 className.getString());
1839 throw CQLRuntimeException(mload);
1840 }
1841 _setValue(CIMValue(Sint64(CQLUtilities::stringToSint64(valueMapArray[matchIndex]))));
|
1842 chuck 1.2
1843 PEG_METHOD_EXIT();
1844 return;
1845 }
1846
1847 }
1848
1849 Boolean CQLValueRep::_compareObjects(CIMObject& _in1, CIMObject& _in2)
1850 {
1851 if(_in1.isClass() != _in2.isClass())
1852 {
1853 return false;
1854 }
1855 else if(_in1.isClass())
1856 { // objects are classes
|
1857 humberto 1.16 return ((_in1.getClassName() == _in2.getClassName()) && _in1.identical(_in2));
|
1858 chuck 1.2 }
1859 else
1860 { // objects are instances
1861
|
1862 humberto 1.16 if(!(_in1.getClassName() ==
1863 _in2.getClassName()))
1864 {
1865 return false;
1866 }
1867
|
1868 chuck 1.2 if(_in1.getPropertyCount() !=
1869 _in2.getPropertyCount())
1870 {
1871 return false;
1872 }
1873
1874 Array<CIMProperty> prop1;
1875 Array<CIMProperty> prop2;
1876 Boolean result;
1877
1878 for(Uint32 i = 0; i < _in1.getPropertyCount(); ++i)
1879 {
1880 prop1.append(_in1.getProperty(i));
1881 prop2.append(_in2.getProperty(i));
1882 }
1883
1884 for(Uint32 i = 0; i < _in1.getPropertyCount(); ++i)
1885 {
1886 result = false;
1887
1888 for(Uint32 j = 0; j < _in2.getPropertyCount(); ++j)
1889 chuck 1.2 {
1890 if(prop1[i].getName() == prop2[j].getName())
1891 {
|
1892 david 1.9 if(prop1[i].isArray() != prop2[j].isArray())
|
1893 chuck 1.2 {
1894 break;
1895 }
|
1896 david 1.9 if(prop1[i].isArray())
1897 {
1898 CQLValueRep left;
1899 CQLValueRep right;
1900 left._setValue(prop1[i].getValue());
1901 right._setValue(prop2[j].getValue());
1902 result = left._compareArray(right);
1903 }
|
1904 chuck 1.2 else
1905 {
|
1906 david 1.9 if(CQLValue(prop1[i].getValue()) == CQLValue(prop2[j].getValue()))
1907 {
1908 result = true;
1909 break;
1910 }
1911 else
1912 {
1913 result = false;
1914 break;
1915 }
|
1916 chuck 1.2 }
1917 }
1918 }
1919 if(result == false)
1920 {
1921 return false;
1922 }
1923 }
1924 }
1925 return true;
1926 }
1927
1928 Boolean CQLValueRep::_compareArray(const CQLValueRep& _in)
1929 {
1930 PEG_METHOD_ENTER(TRC_CQL,"CQLValueRep::_compareArray()");
|
1931 humberto 1.16
|
1932 chuck 1.2
1933 Boolean result;
1934 Array<Boolean> _bool1;
1935 Array<Boolean> _bool2;
1936 Array<Uint64> _uint1;
1937 Array<Uint64> _uint2;
1938 Array<Sint64> _sint1;
1939 Array<Sint64> _sint2;
1940 Array<Real64> _real1;
1941 Array<Real64> _real2;
1942 Array<String> _str1;
1943 Array<String> _str2;
1944 Array<CIMDateTime> _date1;
1945 Array<CIMDateTime> _date2;
1946 Array<CIMObjectPath> _path1;
1947 Array<CIMObjectPath> _path2;
1948 Array<CIMObject> _obj1;
1949 Array<CIMObject> _obj2;
1950
1951 Array<CQLValue> _cqlVal1;
1952 Array<CQLValue> _cqlVal2;
1953 chuck 1.2
1954 CIMValue _in1 = _theValue;
1955 CIMValue _in2 = _in._theValue;
1956
1957 String _arrayType1 = _ArrayType;
1958 String _arrayType2 = _in._ArrayType;
1959
1960 switch(_in1.getType())
1961 {
1962 case CIMTYPE_BOOLEAN:
1963 {
1964 _in1.get(_bool1);
1965 for(Uint32 i = 0; i < _bool1.size(); ++i)
1966 {
1967 _cqlVal1.append(CQLValue(_bool1[i]));
1968 }
|
1969 david 1.9 break;
|
1970 chuck 1.2 }
1971 case CIMTYPE_UINT64:
1972 {
1973 _in1.get(_uint1);
1974 for(Uint32 i = 0; i < _uint1.size(); ++i)
1975 {
1976 _cqlVal1.append(CQLValue(_uint1[i]));
1977 }
1978 break;
1979 }
1980 case CIMTYPE_SINT64:
1981 {
1982 _in1.get(_sint1);
1983 for(Uint32 i = 0; i < _sint1.size(); ++i)
1984 {
1985 _cqlVal1.append(CQLValue(_sint1[i]));
1986 }
1987 break;
1988 }
1989 case CIMTYPE_REAL64:
1990 {
1991 chuck 1.2 _in1.get(_real1);
1992 for(Uint32 i = 0; i < _real1.size(); ++i)
1993 {
1994 _cqlVal1.append(CQLValue(_real1[i]));
1995 }
1996 break;
1997 }
1998 case CIMTYPE_STRING:
1999 {
2000 _in1.get(_str1);
2001 for(Uint32 i = 0; i < _str1.size(); ++i)
2002 {
2003 _cqlVal1.append(CQLValue(_str1[i]));
2004 }
2005 break;
2006 }
2007 case CIMTYPE_DATETIME:
2008 {
2009 _in1.get(_date1);
2010 for(Uint32 i = 0; i < _date1.size(); ++i)
2011 {
2012 chuck 1.2 _cqlVal1.append(CQLValue(_date1[i]));
2013 }
2014 break;
2015 }
2016 case CIMTYPE_REFERENCE:
2017 {
2018 _in1.get(_path1);
2019 for(Uint32 i = 0; i < _path1.size(); ++i)
2020 {
2021 _cqlVal1.append(CQLValue(_path1[i]));
2022 }
2023 break;
2024 }
|
2025 david 1.8 case CIMTYPE_OBJECT:
|
2026 chuck 1.2 {
2027 _in1.get(_obj1);
2028 for(Uint32 i = 0; i < _obj1.size(); ++i)
2029 {
2030 _cqlVal1.append(CQLValue(_obj1[i]));
2031 }
2032 break;
2033 }
2034 default:
2035 MessageLoaderParms mload(String("CQL.CQLValueRep.INVALID_ARRAY_COMPARISON"),
|
2036 humberto 1.16 String("Invalid array comparison type: $0."),
2037 _in1.getType());
|
2038 chuck 1.2 throw CQLRuntimeException(mload);
2039 } // switch statement
2040
2041 switch(_in2.getType())
2042 {
2043 case CIMTYPE_BOOLEAN:
2044 {
2045 _in2.get(_bool2);
2046 for(Uint32 i = 0; i < _bool2.size(); ++i)
2047 {
2048 _cqlVal2.append(CQLValue(_bool2[i]));
2049 }
|
2050 david 1.9 break;
|
2051 chuck 1.2 }
2052 case CIMTYPE_UINT64:
2053 {
2054 _in2.get(_uint2);
2055 for(Uint32 i = 0; i < _uint2.size(); ++i)
2056 {
2057 _cqlVal2.append(CQLValue(_uint2[i]));
2058 }
2059 break;
2060 }
2061 case CIMTYPE_SINT64:
2062 {
2063 _in2.get(_sint2);
2064 for(Uint32 i = 0; i < _sint2.size(); ++i)
2065 {
2066 _cqlVal2.append(CQLValue(_sint2[i]));
2067 }
2068 break;
2069 }
2070 case CIMTYPE_REAL64:
2071 {
2072 chuck 1.2 _in2.get(_real2);
2073 for(Uint32 i = 0; i < _real2.size(); ++i)
2074 {
2075 _cqlVal2.append(CQLValue(_real2[i]));
2076 }
2077 break;
2078 }
2079 case CIMTYPE_STRING:
2080 {
2081 _in2.get(_str2);
2082 for(Uint32 i = 0; i < _str2.size(); ++i)
2083 {
2084 _cqlVal2.append(CQLValue(_str2[i]));
2085 }
2086 break;
2087 }
2088 case CIMTYPE_DATETIME:
2089 {
2090 _in2.get(_date2);
2091 for(Uint32 i = 0; i < _date2.size(); ++i)
2092 {
2093 chuck 1.2 _cqlVal2.append(CQLValue(_date2[i]));
2094 }
2095 break;
2096 }
2097 case CIMTYPE_REFERENCE:
2098 {
2099 _in2.get(_path2);
2100 for(Uint32 i = 0; i < _path2.size(); ++i)
2101 {
2102 _cqlVal2.append(CQLValue(_path2[i]));
2103 }
2104 break;
2105 }
|
2106 david 1.8 case CIMTYPE_OBJECT:
|
2107 chuck 1.2 {
2108 _in2.get(_obj2);
2109 for(Uint32 i = 0; i < _obj2.size(); ++i)
2110 {
2111 _cqlVal2.append(CQLValue(_obj2[i]));
2112 }
2113 break;
|
2114 david 1.9 }
|
2115 chuck 1.2 default:
2116 MessageLoaderParms mload(String("CQL.CQLValueRep.INVALID_ARRAY_COMPARISON"),
|
2117 humberto 1.16 String("Invalid array comparison type: $0."),
2118 _in2.getType());
|
2119 chuck 1.2 throw CQLRuntimeException(mload);
2120 } // switch statement
2121
2122 if((_arrayType1 == String("Indexed") ||
2123 _arrayType1 == String("Ordered")) &&
2124 (_arrayType2 == String("Indexed") ||
2125 _arrayType2 == String("Ordered")))
2126 { // Handle the indexed or ordered case.
2127 for(Uint32 i = 0; i < _cqlVal1.size(); ++i)
2128 {
2129 if(_cqlVal1[i] != _cqlVal2[i])
2130 {
2131 PEG_METHOD_EXIT();
2132 return false;
2133 }
2134 }
2135 }
|
2136 humberto 1.16 else // We are doing a bag comparison
|
2137 chuck 1.2 {
2138 for(Uint32 i = 0; i < _cqlVal1.size(); ++i)
2139 {
2140 result = false;
2141
2142 for(Uint32 j = 0; j < _cqlVal2.size(); ++j)
2143 {
2144 if(_cqlVal1[i] == _cqlVal2[j])
2145 {
2146 result = true;
2147 break;
2148 }
2149 }
2150 if(result == false)
2151 {
2152 PEG_METHOD_EXIT();
2153 return false;
2154 }
2155 }
2156
2157 for(Uint32 i = 0; i < _cqlVal2.size(); ++i)
2158 chuck 1.2 {
2159 result = false;
2160
2161 for(Uint32 j = 0; j < _cqlVal1.size(); ++j)
2162 {
2163 if(_cqlVal2[i] == _cqlVal1[j])
2164 {
2165 result = true;
2166 break;
2167 }
2168 }
2169 if(result == false)
2170 {
2171 PEG_METHOD_EXIT();
2172 return false;
2173 }
2174 }
2175 }
2176 PEG_METHOD_EXIT();
2177 return true;
2178 }
2179 chuck 1.2
|
2180 humberto 1.16 String CQLValueRep::valueTypeToString(const CQLValue::CQLValueType parmType)
2181 {
2182 String returnStr;
2183
2184 switch (parmType)
2185 {
2186 case CQLValue::Null_type:
2187 returnStr.append("NULL");
2188 break;
2189 case CQLValue::Sint64_type:
2190 returnStr.append("Sint64");
2191 break;
2192 case CQLValue::Uint64_type:
2193 returnStr.append("Uint64");
2194 break;
2195 case CQLValue::Real_type:
2196 returnStr.append("Real");
2197 break;
2198 case CQLValue::String_type:
2199 returnStr.append("String");
2200 break;
2201 humberto 1.16 case CQLValue::CIMDateTime_type:
2202 returnStr.append("DateTime");
2203 break;
2204 case CQLValue::CIMReference_type:
2205 returnStr.append("CIM Ref");
2206 break;
2207 case CQLValue::CQLIdentifier_type:
2208 returnStr.append("Identifier");
2209 break;
2210 case CQLValue::CIMObject_type:
2211 returnStr.append("CIM Object");
2212 break;
2213 case CQLValue::Boolean_type:
2214 returnStr.append("Boolean");
2215 break;
2216 default:
2217 returnStr.append("Unknown");
2218 }
2219 return returnStr;
2220 }
|
2221 chuck 1.2 PEGASUS_NAMESPACE_END
|
Return to
CQLValueRep.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / CQL