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