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