(file) Return to CQLValueRep.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / CQL

Diff for /pegasus/src/Pegasus/CQL/CQLValueRep.cpp between version 1.1 and 1.1.2.13

version 1.1, 2004/09/28 18:28:00 version 1.1.2.13, 2004/10/15 19:25:46
Line 0 
Line 1 
   //%2003////////////////////////////////////////////////////////////////////////
   //
   // Copyright (c) 2000, 2001, 2002  BMC Software, Hewlett-Packard Development
   // Company, L. P., IBM Corp., The Open Group, Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L. P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a copy
   // of this software and associated documentation files (the "Software"), to
   // deal in the Software without restriction, including without limitation the
   // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   // sell copies of the Software, and to permit persons to whom the Software is
   // furnished to do so, subject to the following conditions:
   //
   // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
   // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
   // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
   // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
   // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //==============================================================================
   //
   // Author: Dave Rosckes (rosckes@us.ibm.com)
   //
   // Modified By:
   //
   //%/////////////////////////////////////////////////////////////////////////////
   
   #include <cstdlib>
   #include <iostream>
   
   #include <Pegasus/CQL/CQLValueRep.h>
   #include <Pegasus/Repository/NameSpaceManager.h>
   #include <Pegasus/Common/CIMClass.h>
   #include <Pegasus/CQL/CQLIdentifier.h>
   
   #include <Pegasus/CQL/CQLFactory.h>
   
   
   
   PEGASUS_NAMESPACE_BEGIN
   PEGASUS_USING_STD;
   
   #define PEGASUS_ARRAY_T CQLValueRep
   #include <Pegasus/Common/ArrayImpl.h>
   #undef PEGASUS_ARRAY_T
   
   
   #define CIMTYPE_EMBEDDED 15  //temporary
   
   CQLValueRep::CQLValueRep()
   {
      _valueType = Null_type;
           _theValue._S = NULL;
   }
   CQLValueRep::~CQLValueRep()
   {
      switch(_valueType)
      {
         case String_type:
         {
            if(_theValue._S != NULL){
               delete _theValue._S;
           }
            _theValue._S = NULL;
            break;
         }
         case CIMDateTime_type:
          {
            if(_theValue._DT != NULL)
               delete _theValue._DT;
            _theValue._DT = NULL;
            break;
         }
         case CIMReference_type:
         {
            if(_theValue._OP != NULL)
               delete _theValue._OP;
            _theValue._OP = NULL;
            break;
         }
         case CIMInstance_type:
         {
            if(_theValue._IN != NULL)
               delete _theValue._IN;
            _theValue._IN = NULL;
            break;
         }
         case CIMClass_type:
         {
            if(_theValue._CL != NULL)
               delete _theValue._CL;
            _theValue._CL = NULL;
            break;
         }
         default:
            break;
      }
   }
   
   CQLValueRep::CQLValueRep(const CQLValueRep* val)
   {
      switch(val->_valueType)
      {
         case Boolean_type:
         {
            _theValue._B = val->_theValue._B;
            break;
         }
         case Sint64_type:
         {
            _theValue._S64 = val->_theValue._S64;
            break;
         }
         case Uint64_type:
         {
            _theValue._U64 = val->_theValue._U64;
            break;
         }
         case Real_type:
         {
            _theValue._R64 = val->_theValue._R64;
            break;
         }
         case String_type:
         {
            _theValue._S = new String(*val->_theValue._S);
            break;
         }
         case CIMDateTime_type:
         {
            _theValue._DT = new CIMDateTime(*val->_theValue._DT);
            break;
         }
         case CIMReference_type:
         {
            _theValue._OP = new CIMObjectPath(*val->_theValue._OP);
            break;
         }
         case CIMInstance_type:
         {
            _theValue._IN = new CIMInstance(*val->_theValue._IN);
            break;
         }
         case CIMClass_type:
         {
            _theValue._CL = new CIMClass(*val->_theValue._CL);
            break;
         }
         default:
            break;
      }
   
         _CQLChainId = val->_CQLChainId;
   
       _isResolved = val->_isResolved;
   
       Num_Type = val->Num_Type;
   
      _valueType = val->_valueType;
   }
   
   CQLValueRep::CQLValueRep(String inString, NumericType inValueType, Boolean inSign)
   {
      CString cStr = inString.getCString();
      char *endP;
   
      switch(inValueType)
      {
         case Hex:
            if(inSign)
            {
               _theValue._U64 = strtoul((const char*)cStr,&endP,16);
               _valueType = Uint64_type;
            }
            else
            {
               _theValue._S64 = strtol((const char *)cStr,&endP,16);
               _valueType = Sint64_type;
            }
   
            break;
         case Binary:
            if(inSign)
            {
               _theValue._U64 = strtoul((const char *)cStr,&endP,2);
               _valueType = Uint64_type;
            }
            else
            {
               _theValue._S64 = strtol((const char *)cStr,&endP,2);
               _valueType = Sint64_type;
            }
            break;
         case Decimal:
            if(inSign)
            {
               _theValue._U64 = strtoul((const char *)cStr,&endP,10);
               _valueType = Uint64_type;
            }
            else
            {
               _theValue._S64 = strtol((const char *)cStr,&endP,10);
               _valueType = Sint64_type;
            }
            break;
         case Real:
            if(inSign)
            {
               _theValue._R64 = strtod((const char *)cStr,&endP);
               _valueType = Real_type;
            }
            else
            {
               _theValue._R64 = strtod((const char *)cStr,&endP);
               _valueType = Real_type;
            }
            break;
         default:
            throw(Exception(String("CQLValueRep::CQLValueRep")));
            break;
      }
      _isResolved = true;
   }
   
   
   CQLValueRep::CQLValueRep(CQLChainedIdentifier inCQLIdent)
   {
      _CQLChainId = inCQLIdent;
      _valueType = CQLIdentifier_type;
      _isResolved = false;
   }
   
   
   CQLValueRep::CQLValueRep(String inString)
   {
      _theValue._S = new String(inString);
      _valueType = String_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(CIMInstance inInstance)
   {
      _theValue._IN = new CIMInstance(inInstance);
      _valueType = CIMInstance_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(CIMClass inClass)
   {
      _theValue._CL = new CIMClass(inClass);
      _valueType = CIMClass_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(CIMObjectPath inObjPath)
   {
      _theValue._OP = new CIMObjectPath(inObjPath);
      _valueType = CIMReference_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(CIMDateTime inDateTime)
   {
      _theValue._DT = new CIMDateTime(inDateTime);
      _valueType = CIMDateTime_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(Uint64 inUint)
   {
      _theValue._U64 = inUint;
      _valueType = Uint64_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(Boolean inBool)
   {
      _theValue._B = inBool;
      _valueType = Boolean_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(Sint64 inSint)
   {
      _theValue._S64 = inSint;
      _valueType = Sint64_type;
      _isResolved = true;
   }
   
   CQLValueRep::CQLValueRep(Real64 inReal)
   {
      _theValue._R64 = inReal;
      _valueType = Real_type;
      _isResolved = true;
   }
   
   void CQLValueRep::resolve(CIMInstance CI, QueryContext& inQueryCtx)
   {
      if(_isResolved)
      {
         return;
      }
   
      CQLIdentifier classNameID;       // Determine if we have Alias/Class/Property
      String className;                // Alias/Class Name
      Array<CQLIdentifier> Idstrings =
         _CQLChainId.getSubIdentifiers(); // Array of Identifiers to process
   
      Uint32 index = 0;                // Counter for looping through Identifiers
   
      CIMClass ScopeClass;             // CIMClass for the scope of Identifier
      CIMClass QueryClass;             // CIMClass for the current query
   
      CIMProperty propObj;             // Property object to be processed
      CIMProperty queryPropObj;        // Property object used for verification
   
      Uint32 qualIndex;                // Counter for looping through qualifiers
      CIMValue valueMap;               // CIMValue for Value Map Qualifiers
      CIMValue values;                 // CIMValue for Values Qualifiers
      Boolean matchFound = false;      // Indicator for match Qualifier
      Uint32 matchIndex;               // Placeholder for matched Qualifier
      Array<String> valueMapArray;     // Value Map Qualifier for property
      Array<String> valuesArray;       // Values Qualifier for property
   
      Boolean isEmbedded = false;      // Embedded indicator
   
      // We need to determine if the first Identifier is an Alias, Class, or Property.
      // If it is a Alias or a Class the CQLIdentifier return will be the
      // Class name. If the first Identifier is a property, the return CQLIdentifier
      // will be empty.
   
      classNameID = inQueryCtx.findClass(Idstrings[index].getName().getString());
   
      className = classNameID.getName().getString();
   
      if(className.size() == 0)
      {
         // classname is an empty string, the first Identifier must be a property.
         // A class is needed to proceed. We will get a class from the FromList.
         // NOTE: for basic CQL support only one class will be in the FromList.
   
         Array<CQLIdentifier> classList;
   
         classList = inQueryCtx.getFromList();
   
         if(classList.size() != 1)
         {
            throw(Exception(String("CQLValueRep::resolve")));
         }
   
         className = classList[0].getName().getString();
   
      }
      else if(Idstrings.size() == 1)
      {
         // A class was passed in with no property indicated.
         // Set the instance passed in, as a primitive.
         _theValue._IN = (CIMInstance *) new CIMInstance(CI);
         _valueType = CIMInstance_type;
         _isResolved = true;
         return; // Done.
      }
      else
      {
         // Need to increment index since the first Identifier is a class,
         // and additional identifiers need processing.
         ++index;
      }
   
      // Symbolic Constant processing
      if(_CQLChainId.getLastIdentifier().isSymbolicConstant())
        {
         _resolveSymbolicConstant(inQueryCtx);
        return;
      }
   
      // Now we will loop through the remaining CQLIdentifiers,
      // and process each one.
      for(;index < Idstrings.size(); ++index)
      {
         // We will get the current class from the repository.
         // We must do this for each loop since the class being
         // processed may change with each iteration.
         QueryClass = inQueryCtx.getClass(className);
   
         // We need to do special processing on property if the
         // property is scoped.
   // TODO: We should be able to delete this code.
   /*
         if(Idstrings[index].isScoped())
         {
            // This property is scoped.
            // We need to get the scoped class from the repository; to verify
            // that the property is in the scope and the scope and QueryClass
            // have a parent child relationship.
            ScopeClass = inQueryCtx.getClass(Idstrings[index].getScope());
   
            // Verifing property is in Scope.
            if(ScopeClass.findProperty(Idstrings[index].getName()) ==
               PEG_NOT_FOUND)
            {
               // Set the Ignore_type
               _valueType = CQLIgnore_type;
               _isResolved = true;
               return;
            }
            // Verifying the QueryClass and the ScopeClass have a
            // parent child relationship
            else if(!_areClassesInline(ScopeClass,QueryClass,inQueryCtx))
            {
               throw(1);
            }
   
         }
         // Verifing that embedded properties are scoped.
         else if(isEmbedded)
         {  // all embedded properties must be scoped.
   
            throw(1);
         }
   */
         // This is a short cut for wildcard special charactor.
         // Since no further processing is necessary for this case.
         if(Idstrings[index].isWildcard())
         {
            _theValue._IN = new CIMInstance(CI);
            _valueType = CIMInstance_type;
            _isResolved = true;
            return;
         }
   
         // Now we need to verify that the property is in the class.
         Uint32 propertyIndex = QueryClass.findProperty(Idstrings[index].getName());
   
         if(propertyIndex == PEG_NOT_FOUND)
         {
            throw(Exception(String("CQLValueRep::resolve -- Property not Found")));
         }
   
         // We will check the property type to determine what processing
         // needs to be done.
         queryPropObj = QueryClass.getProperty(propertyIndex);
   
         if(queryPropObj.getType() == CIMTYPE_EMBEDDED)
         {
            // Do embedded code here.
   
            isEmbedded = true;
            continue;
         }
         else // Primitive
         {
            // We will retrieve the property from the instance,
            // that will be used to set the primitive later in processing.
            propertyIndex = CI.findProperty(Idstrings[index].getName());
            propObj = CI.getProperty(propertyIndex);
   
            if(Idstrings[index].isArray())
            {
               // We have an array property.  All we need to do
               // Is get the index defined by CQLIdentifier.
               // NOTE: Basic CQL support only allows one index.
               _setValue(propObj.getValue(),
                        Idstrings[index].getSubRanges()[0].start);
               return;
            }
            else
            {
               // The property has no special charactors.
               CIMValue cimVal = propObj.getValue();
               _setValue(cimVal);
               return;
            }
         } // else body
      } // loop
   } // end of function
   
   CQLValueRep& CQLValueRep::operator=(const CQLValueRep& rhs){
   
           if(&rhs != this){
                   _valueType = rhs._valueType;
                   _theValue = rhs._theValue;
                   switch(_valueType){
                           case String_type:
                                   _theValue._S = new String(rhs.getString());
                                   break;
                           case CIMDateTime_type:
                                   _theValue._DT = new CIMDateTime(rhs.getDateTime());
                                   break;
                           case CIMReference_type:
                                   _theValue._OP = new CIMObjectPath(rhs.getReference());
                                   break;
                           case CIMInstance_type:
                                   _theValue._IN = new CIMInstance(rhs.getInstance());
                                   break;
                           case CIMClass_type:
                                   _theValue._CL = new CIMClass(rhs.getClass());
                                   break;
                           case Boolean_type:
                           case Sint64_type:
                           case Uint64_type:
                           case Real_type:
                           case Null_type:
                           case CQLIdentifier_type:
                           case CQLIgnore_type:
                           default:
                                   break;
                   }
                   _CQLChainId = rhs._CQLChainId;
                   _isResolved = rhs._isResolved;
                   Num_Type = rhs.Num_Type;
           }
           return *this;
   }
   Boolean CQLValueRep::operator==(const CQLValueRep& x)
   {
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator==")));
      }
   
      if(x._valueType == Null_type ||
         _valueType == Null_type)
      {
         throw(Exception(String("CQLValueRep::operator==")));
      }
   
      switch(_valueType)
      {
         case Boolean_type:
         {
            if(x._valueType == Boolean_type)
            {
               if(_theValue._B == x._theValue._B)
               {
                  return true;
               }
            }
            break;
         }
         case Sint64_type:
         {
            if(x._valueType == Sint64_type)
            {
               if(_theValue._S64 == x._theValue._S64)
               {
                  return true;
               }
            }
            else if(x._valueType == Uint64_type)
            {
               if(_theValue._S64 == (Sint64)x._theValue._U64)
               {
                  return true;
               }
            }
            else if(x._valueType == Real_type)
            {
               if(_theValue._S64 == x._theValue._R64)
               {
                  return true;
               }
            }
            break;
         }
         case Uint64_type:
            if(x._valueType == Sint64_type)
            {
               if((Sint64)_theValue._U64 == x._theValue._S64)
               {
                  return true;
               }
            }
            else if(x._valueType == Uint64_type)
            {
               if(_theValue._U64 == x._theValue._U64)
               {
                  return true;
               }
            }
            else if(x._valueType == Real_type)
            {
                   Real64 temp;
                   memcpy(&temp, &_theValue._U64, sizeof(temp));
               if(temp == x._theValue._R64)
               {
                  return true;
               }
            }
            break;
         case Real_type:
            if(x._valueType == Sint64_type)
            {
               if(_theValue._R64 == x._theValue._S64)
               {
                  return true;
               }
            }
            else if(x._valueType == Uint64_type)
            {
                   Real64 temp;
                   memcpy(&temp, &x._theValue._U64, sizeof(temp));
               if(_theValue._R64 == temp)
               {
                  return true;
               }
            }
            else if(x._valueType == Real_type)
            {
               if(_theValue._R64 == x._theValue._R64)
               {
                  return true;
               }
            }
            break;
         case String_type:
            if(*_theValue._S == *x._theValue._S)
            {
               return true;
            }
            break;
         case CIMDateTime_type:
            if(*_theValue._DT == *x._theValue._DT)
            {
               return true;
            }
            break;
            case CIMReference_type:
            if(*_theValue._OP == *x._theValue._OP)
            {
               return true;
            }
            break;
            case CIMInstance_type:
            if((*_theValue._IN).getPath() == (*x._theValue._IN).getPath())
            {
               return true;
            }
            break;
            case CQLIdentifier_type:
               throw(Exception(String("")));
            break;
   
         default:
            throw(Exception(String("CQLValueRep::operator==")));
            break;
      }
      return false;
   }
   
   //##ModelId=40FBFF9502BB
   Boolean CQLValueRep::operator!=(const CQLValueRep& x)
   {
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator!=")));
      }
   
      return !(this->operator==(x));
   }
   
   
   Boolean CQLValueRep::operator<=(const CQLValueRep& x)
   {
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator<=")));
      }
   
      if (this->operator<(x) || this->operator==(x))
                   return true;
      return false;
   }
   
   
   Boolean CQLValueRep::operator>=(const CQLValueRep& x)
   {
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator>=")));
      }
      return !(this->operator<(x));
   }
   
   
   Boolean CQLValueRep::operator<(const CQLValueRep& x)
   {
   if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator<")));
      }
   
      if(x._valueType == Null_type ||
         _valueType == Null_type)
      {
         throw(Exception(String("CQLValueRep::operator<")));
      }
   
      switch(_valueType)
      {
         case Boolean_type:
         {
            if(x._valueType == Boolean_type)
            {
               if(_theValue._B < x._theValue._B)
               {
                  return true;
               }
            }
            break;
         }
         case Sint64_type:
            if(x._valueType == Sint64_type)
            {
               if(_theValue._S64 < x._theValue._S64)
               {
                  return true;
               }
            }
            else if(x._valueType == Uint64_type)
            {
               if(_theValue._S64 < (Sint64)x._theValue._U64)
               {
                  return true;
               }
            }
            else if(x._valueType == Real_type)
            {
               if(_theValue._S64 < x._theValue._R64)
               {
                  return true;
               }
            }
            break;
         case Uint64_type:
            if(x._valueType == Sint64_type)
            {
               if((Sint64)_theValue._U64 < x._theValue._S64)
               {
                  return true;
               }
            }
            else if(x._valueType == Uint64_type)
            {
               if(_theValue._U64 < x._theValue._U64)
               {
                  return true;
               }
            }
            else if(x._valueType == Real_type)
            {
                   Real64 temp;
                   memcpy(&temp, &_theValue._U64, sizeof(temp));
               if(temp < x._theValue._R64)
               {
                  return true;
               }
            }
            break;
         case Real_type:
            if(x._valueType == Sint64_type)
            {
               if(_theValue._R64 < x._theValue._S64)
               {
                  return true;
               }
            }
            else if(x._valueType == Uint64_type)
            {
                   Real64 temp;
                   memcpy(&temp, &x._theValue._U64, sizeof(temp));
               if(_theValue._R64 < temp)
               {
                  return true;
               }
            }
            else if(x._valueType == Real_type)
            {
               if(_theValue._R64 < x._theValue._R64)
               {
                  return true;
               }
            }
            break;
         case String_type:
            if(*_theValue._S < *x._theValue._S)
            {
               return true;
            }
            break;
         case CIMDateTime_type:
            throw(Exception(String("CQLValueRep::operator<")));
            break;
         case CIMReference_type:
            throw(Exception(String("CQLValueRep::operator<")));
            break;
         case CIMInstance_type:
               throw(Exception(String("CQLValueRep::operator<")));
            break;
         case CQLIdentifier_type:
               throw(Exception(String("CQLValueRep::operator<")));
            break;
   
         default:
            throw(Exception(String("CQLValueRep::operator<")));
            break;
      }
      return false;
   }
   
   
   Boolean CQLValueRep::operator>(const CQLValueRep& x)
   {
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator>")));
      }
      if (this->operator<(x) || this->operator==(x))
                   return false;
      return true;
   }
   
   
   CQLValueRep CQLValueRep::operator+(const CQLValueRep x)
   {
   
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator+")));
      }
   
      if(x._valueType == Null_type ||
         _valueType == Null_type)
      {
         return CQLValueRep();
      }
   
      switch(_valueType)
      {
         case Boolean_type:
            throw(Exception(String("CQLValueRep::operator+")));
            break;
         case Sint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._S64 + x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._S64 + x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._S64 + x._theValue._R64);
            }
            break;
         case Uint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._U64 + x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._U64 + x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
                   Real64 temp;
                   memcpy(&temp, &_theValue._U64, sizeof(temp));
               return CQLValueRep(temp + x._theValue._R64);
            }
            break;
         case Real_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._R64 + x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
                   Real64 temp;
                   memcpy(&temp, &x._theValue._U64, sizeof(temp));
               return CQLValueRep(_theValue._R64 + temp);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._R64 + x._theValue._R64);
            }
            break;
         case String_type:
            return CQLValueRep(*_theValue._S + *x._theValue._S);
            break;
         case CIMDateTime_type:
            throw(Exception(String("CQLValueRep::operator+")));
            break;
         case CIMReference_type:
            throw(Exception(String("CQLValueRep::operator+")));
            break;
         case CIMInstance_type:
               throw(Exception(String("CQLValueRep::operator+")));
            break;
         case CQLIdentifier_type:
               throw(Exception(String("CQLValueRep::operator+")));
            break;
   
         default:
            throw(Exception(String("CQLValueRep::operator+")));
            break;
      }
   
      // control should never reach here
      return x;
   }
   
   
   CQLValueRep CQLValueRep::operator-(const CQLValueRep& x)
   {
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator-")));
      }
      if(x._valueType == Null_type ||
         _valueType == Null_type)
      {
         return CQLValueRep();
      }
   
      switch(_valueType)
      {
         case Boolean_type:
            throw(Exception(String("CQLValueRep::operator-")));
            break;
         case Sint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._S64 - x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._S64 - x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._S64 - x._theValue._R64);
            }
            break;
         case Uint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._U64 - x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._U64 - x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
                   Real64 temp;
                   memcpy(&temp, &_theValue._U64, sizeof(temp));
               return CQLValueRep(temp - x._theValue._R64);
            }
            break;
         case Real_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._R64 - x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
                   Real64 temp;
                   memcpy(&temp, &x._theValue._U64, sizeof(temp));
               return CQLValueRep(_theValue._R64 - temp);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._R64 - x._theValue._R64);
            }
            break;
         case String_type:
            throw(Exception(String("CQLValueRep::operator-")));
            break;
         case CIMDateTime_type:
            throw(Exception(String("CQLValueRep::operator-")));
            break;
         case CIMReference_type:
            throw(Exception(String("CQLValueRep::operator-")));
            break;
         case CIMInstance_type:
               throw(Exception(String("CQLValueRep::operator-")));
            break;
         case CQLIdentifier_type:
               throw(Exception(String("CQLValueRep::operator-")));
            break;
   
         default:
            throw(Exception(String("CQLValueRep::operator-")));
            break;
      }
      // control should never reach here
      return x;
   }
   
   
   CQLValueRep CQLValueRep::operator*(const CQLValueRep& x)
   {
   
      if(!_validate(x))
      {
         throw(Exception(String("CQLValueRep::operator*")));
      }
   
      if(x._valueType == Null_type ||
         _valueType == Null_type)
      {
         return CQLValueRep();
      }
   
      switch(_valueType)
      {
         case Boolean_type:
            throw(Exception(String("CQLValueRep::operator*")));
            break;
         case Sint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._S64 * x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._S64 * x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._S64 * x._theValue._R64);
            }
            break;
         case Uint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._U64 * x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._U64 * x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
                   Real64 temp;
                   memcpy(&temp, &_theValue._U64, sizeof(temp));
               return CQLValueRep(temp * x._theValue._R64);
            }
            break;
         case Real_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._R64 * x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
                   Real64 temp;
                   memcpy(&temp, &x._theValue._U64, sizeof(temp));
               return CQLValueRep(_theValue._R64 * temp);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._R64 * x._theValue._R64);
            }
            break;
         case String_type:
            throw(Exception(String("CQLValueRep::operator*")));
            break;
         case CIMDateTime_type:
            throw(Exception(String("CQLValueRep::operator*")));
            break;
         case CIMReference_type:
            throw(Exception(String("CQLValueRep::operator*")));
            break;
         case CIMInstance_type:
               throw(Exception(String("CQLValueRep::operator*")));
            break;
         case CQLIdentifier_type:
               throw(Exception(String("CQLValueRep::operator*")));
            break;
   
         default:
            throw(Exception(String("CQLValueRep::operator*")));
            break;
      }
      // control should never reach here
      return x;
   }
   
   
   CQLValueRep CQLValueRep::operator/(const CQLValueRep& x)
   {
      if(!_validate(x) ||
         x._theValue._U64 == 0)
      {
         throw(Exception(String("CQLValueRep::operator/")));
      }
   
      if(x._valueType == Null_type ||
         _valueType == Null_type)
      {
         return CQLValueRep();
      }
   
      switch(_valueType)
      {
         case Boolean_type:
            throw(Exception(String("CQLValueRep::operator/")));
            break;
         case Sint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._S64 / x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._S64 / x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._S64 / x._theValue._R64);
            }
            break;
         case Uint64_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._U64 / x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
               return CQLValueRep(_theValue._U64 / x._theValue._U64);
            }
            else if(x._valueType == Real_type)
            {
                   Real64 temp;
                   memcpy(&temp, &_theValue._U64, sizeof(temp));
               return CQLValueRep(temp / x._theValue._R64);
            }
            break;
         case Real_type:
            if(x._valueType == Sint64_type)
            {
               return CQLValueRep(_theValue._R64 / x._theValue._S64);
            }
            else if(x._valueType == Uint64_type)
            {
                   Real64 temp;
                   memcpy(&temp, &x._theValue._U64, sizeof(temp));
               return CQLValueRep(_theValue._R64 / temp);
            }
            else if(x._valueType == Real_type)
            {
               return CQLValueRep(_theValue._R64 / x._theValue._R64);
            }
            break;
         case String_type:
            throw(Exception(String("CQLValueRep::operator/")));
            break;
         case CIMDateTime_type:
            throw(Exception(String("CQLValueRep::operator/")));
            break;
         case CIMReference_type:
            throw(Exception(String("CQLValueRep::operator/")));
            break;
         case CIMInstance_type:
               throw(Exception(String("CQLValueRep::operator/")));
            break;
         case CQLIdentifier_type:
               throw(Exception(String("CQLValueRep::operator/")));
            break;
   
         default:
            throw(Exception(String("CQLValueRep::operator/")));
            break;
      }
      // control should never reach here
      return x;
   }
   
   //##ModelId=40FC3F6F0302
   CQLValueType CQLValueRep::getValueType()
   {
      return _valueType;
   }
   
   
   void CQLValueRep::setNull()
   {
      _valueType = Null_type;
      _isResolved = true;
   }
   
   
   Boolean CQLValueRep::isResolved()
   {
      return _isResolved;
   }
   
   
   Boolean CQLValueRep::isNull()
   {
      if(_valueType == Null_type)
      {
         return true;
      }
      return false;
   }
   
   
   Boolean CQLValueRep::isa(const CQLValueRep& inVal, QueryContext& QueryCtx)
   {
      if(!_isResolved ||
         !inVal._isResolved ||
         _valueType != CIMInstance_type ||
         inVal._valueType != String_type)
      {
         throw(Exception(String("CQLValueRep::isa")));
      }
   
      CIMName  className;
      CIMClass classObj;
   
      className = this->_theValue._IN->getClassName();
   
      while(!className.isNull())
      {
         if(className == CIMName(*inVal._theValue._S))
         {
            return true;
         }
   
         classObj = QueryCtx.getClass(className);
         className = classObj.getSuperClassName();
      }
   
      return false;
   }
   
   
   Boolean CQLValueRep::like(const CQLValueRep& inVal)
   {
      if( _valueType != String_type ||
         inVal._valueType != String_type)
      {
         throw(Exception(String("CQLValueRep::like")));
      }
   
      // Poughkepsie is doing this, Dan Gorey.
      return false;
   }
   
   void CQLValueRep::invert()
   {
      switch(_valueType)
      {
         case Sint64_type:
            _theValue._S64 = -1 * _theValue._S64;
            break;
         case Real_type:
            _theValue._R64 = -1 * _theValue._R64;
            break;
         case Boolean_type:
            _theValue._B = !_theValue._B;
            break;
         default:
            break;
      }
   }
   
   CQLChainedIdentifier CQLValueRep::getChainedIdentifier()const
   {
      return _CQLChainId;
   }
   
   Uint64 CQLValueRep::getUint()const
   {
      if(_valueType != Uint64_type)
      {
         throw(Exception(String("CQLValueRep::getUint")));
      }
      return _theValue._U64;
   }
   
   Boolean CQLValueRep::getBool()const
   {
      if(_valueType != Boolean_type)
      {
         throw(Exception(String("CQLValueRep::getBool")));
      }
      return _theValue._B;
   }
   
   Sint64 CQLValueRep::getSint()const
   {
      if(_valueType != Sint64_type)
      {
         throw(Exception(String("CQLValueRep::getSint")));
      }
      return _theValue._S64;
   }
   
   Real64 CQLValueRep::getReal()const
   {
      if(_valueType != Real_type)
      {
         throw(Exception(String("CQLValueRep::getReal")));
      }
      return _theValue._R64;
   }
   
   String CQLValueRep::getString()const
   {
      if(_valueType != String_type)
      {
         throw(Exception(String("CQLValueRep::getString")));
      }
      return *_theValue._S;
   }
   
   CIMDateTime CQLValueRep::getDateTime()const
   {
      if(_valueType != CIMDateTime_type)
      {
         throw(Exception(String("CQLValueRep::getDateTime")));
      }
   
      return *_theValue._DT;
   }
   
   CIMObjectPath CQLValueRep::getReference()const
   {
      if(_valueType != CIMReference_type)
      {
         throw(Exception(String("CQLValueRep::getReference")));
      }
      return *_theValue._OP;
   }
   
   CIMInstance CQLValueRep::getInstance()const
   {
      if(_valueType != CIMInstance_type)
      {
         throw(Exception(String("CQLValueRep::getInstance")));
      }
      return *_theValue._IN;
   }
   
   CIMClass CQLValueRep::getClass()const
   {
      if(_valueType != CIMClass_type)
      {
         throw(Exception(String("CQLValueRep::getClass")));
      }
   
      return *_theValue._CL;
   }
   
   String CQLValueRep::toString()const
   {
      switch(_valueType)
      {
         case Boolean_type:
         {
            return (_theValue._B ? String("TRUE") : String("FALSE"));
            break;
         }
         case Sint64_type:
         {
            char buffer[32];  // Should need 21 chars max
            sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "d", _theValue._S64);
            return String(buffer);
            break;
         }
         case Uint64_type:
         {
            char buffer[32];  // Should need 21 chars max
            sprintf(buffer, "%" PEGASUS_64BIT_CONVERSION_WIDTH "u", _theValue._U64);
            return String(buffer);
            break;
         }
         case Real_type:
         {
            char buffer[128];
            sprintf(buffer, "%.6e", _theValue._R64);
            return String(buffer);
            break;
         }
         case String_type:
            return *_theValue._S;
            break;
         case CIMDateTime_type:
            return _theValue._DT->toString();
            break;
         case CIMReference_type:
            return _theValue._OP->toString();
            break;
         case CIMInstance_type:
            return _theValue._IN->getPath().toString();
            break;
         case CIMClass_type:
            return _theValue._CL->getPath().toString();
            break;
         case CQLIdentifier_type:
                return _CQLChainId.toString();
                break;
         default:
            break;
      }
      return String();
   }
   
   
   
   Boolean CQLValueRep::_validate(const CQLValueRep& x)
   {
      switch(_valueType)
      {
         case Boolean_type:
            if(x._valueType != Boolean_type)
            {
               return false;
            }
            break;
         case Sint64_type:
         case Uint64_type:
         case Real_type:
            if(x._valueType != Sint64_type &&
               x._valueType != Uint64_type &&
               x._valueType != Real_type)
            {
               return false;
            }
            break;
         case String_type:
            if(x._valueType != String_type)
            {
               return false;
            }
            break;
         case CIMDateTime_type:
            if(x._valueType != CIMDateTime_type)
            {
               return false;
            }
            break;
         case CIMReference_type:
            if(x._valueType != CIMReference_type)
            {
               return false;
            }
            break;
         case CIMInstance_type:
            if(x._valueType != CIMInstance_type)
            {
               return false;
            }
            break;
         case CQLIdentifier_type:
            if(x._valueType != CQLIdentifier_type)
            {
               return false;
            }
            break;
   
         default:
            throw(Exception(String("CQLValueRep::_validate")));
            break;
      }
      return true;
   }
   
   Boolean CQLValueRep::_areClassesInline(CIMClass c1,CIMClass c2,QueryContext& QC)
   {
      CIMName superClass;
      CIMName prevClass;
   
      superClass = c1.getClassName();
      while(!(superClass == prevClass))
      {
         prevClass = superClass;
         if(superClass == c2.getClassName())
         {
            return true;
         }
         superClass = c1.getSuperClassName();
      }
      prevClass = CIMName();
      superClass = c2.getClassName();
      while(!(superClass == prevClass))
      {
         prevClass = superClass;
         if(superClass == c1.getClassName())
         {
            return true;
         }
         superClass = c2.getSuperClassName();
      }
   
      return false;
   }
   
   void CQLValueRep::_setValue(CIMValue cv,Uint64 index)
   {
      CIMValue tmp;
      if(cv.isArray())
      {
         switch(cv.getType())
         {
            case CIMTYPE_BOOLEAN:
            {
               Array<Boolean> _bool;
               cv.get(_bool);
               _theValue._B = _bool[index];
               _valueType = Boolean_type;
               break;
            }
            case CIMTYPE_UINT8:
            {
               Array<Uint8> _uint;
               cv.get(_uint);
               _theValue._U64 = _uint[index];
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_UINT16:
            {
               Array<Uint16> _uint;
               cv.get(_uint);
               _theValue._U64 = _uint[index];
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_UINT32:
            {
               Array<Uint32> _uint;
               cv.get(_uint);
               _theValue._U64 = _uint[index];
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_UINT64:
            {
               Array<Uint64> _uint;
               cv.get(_uint);
               _theValue._U64 = _uint[index];
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_SINT8:
            {
               Array<Sint8> _sint;
               cv.get(_sint);
               _theValue._S64 = _sint[index];
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_SINT16:
            {
               Array<Sint16> _sint;
               cv.get(_sint);
               _theValue._S64 = _sint[index];
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_SINT32:
            {
               Array<Sint32> _sint;
               cv.get(_sint);
               _theValue._S64 = _sint[index];
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_SINT64:
            {
               Array<Sint64> _sint;
               cv.get(_sint);
               _theValue._S64 = _sint[index];
               _valueType = Sint64_type;
               break;
            }
   
            case CIMTYPE_REAL32:
            {
               Array<Real32> _real;
               cv.get(_real);
               _theValue._R64 = _real[index];
               _valueType = Real_type;
               break;
            }
            case CIMTYPE_REAL64:
            {
               Array<Real64> _real;
               cv.get(_real);
               _theValue._R64 = _real[index];
               _valueType = Real_type;
               break;
            }
            case CIMTYPE_CHAR16:
            {
               Array<Char16> _str;
               cv.get(_str);
               _theValue._S = new String(&_str[index]);
               _valueType = String_type;
               break;
            }
            case CIMTYPE_STRING:
            {
               Array<String> _str;
               cv.get(_str);
               _theValue._S = new String(_str[index]);
               _valueType = String_type;
               break;
            }
            case CIMTYPE_DATETIME:
            {
               Array<CIMDateTime> _date;
               cv.get(_date);
               _theValue._DT = new CIMDateTime(_date[index]);
               _valueType = CIMDateTime_type;
               break;
            }
            case CIMTYPE_REFERENCE:
            {
               Array<CIMObjectPath> _path;
               cv.get(_path);
               _theValue._OP = new CIMObjectPath(_path[index]);
               _valueType = CIMReference_type;
               break;
            }
            default:
               throw(Exception(String("CQLValueRep::_setValue")));
         } // switch statement
   
      }
      else
      {
         switch(cv.getType())
         {
            case CIMTYPE_BOOLEAN:
            {
               Boolean _bool;
               cv.get(_bool);
               _theValue._B = _bool;
               _valueType = Boolean_type;
               break;
            }
            case CIMTYPE_UINT8:
            {
               Uint8 _uint;
               cv.get(_uint);
               _theValue._U64 = _uint;
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_UINT16:
            {
               Uint16 _uint;
               cv.get(_uint);
               _theValue._U64 = _uint;
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_UINT32:
            {
               Uint32 _uint;
               cv.get(_uint);
               _theValue._U64 = _uint;
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_UINT64:
            {
               Uint64 _uint;
               cv.get(_uint);
               _theValue._U64 = _uint;
               _valueType = Uint64_type;
               break;
            }
            case CIMTYPE_SINT8:
            {
               Sint8 _sint;
               cv.get(_sint);
               _theValue._S64 = _sint;
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_SINT16:
            {
               Sint16 _sint;
               cv.get(_sint);
               _theValue._S64 = _sint;
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_SINT32:
   
            {
               Sint32 _sint;
               cv.get(_sint);
               _theValue._S64 = _sint;
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_SINT64:
            {
               Sint64 _sint;
               cv.get(_sint);
               _theValue._S64 = _sint;
               _valueType = Sint64_type;
               break;
            }
            case CIMTYPE_REAL32:
            {
               Real32 _real;
               cv.get(_real);
               _theValue._R64 = _real;
               _valueType = Real_type;
               break;
            }
            case CIMTYPE_REAL64:
            {
               Real64 _real;
               cv.get(_real);
               _theValue._R64 = _real;
               _valueType = Real_type;
               break;
            }
            case CIMTYPE_CHAR16:
            {
               Char16 _str;
               cv.get(_str);
               _theValue._S = new String(&_str);
               _valueType = String_type;
               break;
            }
            case CIMTYPE_STRING:
            {
               String _str;
               cv.get(_str);
               _theValue._S = new String(_str);
               _valueType = String_type;
               break;
            }
            case CIMTYPE_DATETIME:
            {
               CIMDateTime _date;
               cv.get(_date);
               _theValue._DT = new CIMDateTime(_date);
               _valueType = CIMDateTime_type;
               break;
            }
            case CIMTYPE_REFERENCE:
            {
               CIMObjectPath _path;
               cv.get(_path);
               _theValue._OP = new CIMObjectPath(_path);
               _valueType = CIMReference_type;
               break;
            }
            default:
               throw(Exception(String("CQLValueRep::setValue")));
         } // switch statement
      }
      _isResolved = true;
      return;
   }
   
   void CQLValueRep::applyContext(QueryContext& _ctx,
                                 CQLChainedIdentifier& inCid)
   {
      printf("CQLValueRep::applyContext 0\n");
      if(inCid.size() != 0 && _CQLChainId.size() == 1)
      {
   
         _CQLChainId[0].setName(inCid[inCid.size()-1].getName());
         _CQLChainId[0].applyScope(inCid[inCid.size()-1].getScope());
   
         for(Sint32 i = inCid.size()-2; i >= 0; --i)
         {
            _CQLChainId.prepend(inCid[i]);
         }
   
         resolve(CIMInstance(),_ctx);
      }
      else
      {
         _CQLChainId.applyContext(_ctx);
      }
   }
   
   void CQLValueRep::_resolveSymbolicConstant(QueryContext& inQueryCtx)
   {
      Array<String> valueMapArray;     // Value Map Qualifier for property
      Array<String> valuesArray;       // Values Qualifier for property
      CIMName className;
      CQLIdentifier lid = _CQLChainId.getLastIdentifier();
      CIMClass QueryClass;
      CIMValue valueMap;               // CIMValue for Value Map Qualifiers
      CIMValue values;                 // CIMValue for Values Qualifiers
      Boolean matchFound = false;      // Indicator for match Qualifier
      Uint32 matchIndex;               // Placeholder for matched Qualifier
   
      if(lid.isScoped())
      {
         className = lid.getScope();
      }
      else
      {
         className = _CQLChainId[0].getName();
      }
   
      QueryClass = inQueryCtx.getClass(className);
   
      Uint32 propertyIndex =
            QueryClass.findProperty(lid.getName());
   
      if(propertyIndex == PEG_NOT_FOUND)
      {
         throw(Exception(String("CQLValueRep::_resolveSymbolicConstant")));
      }
   
      CIMProperty queryPropObj = QueryClass.getProperty(propertyIndex);
   
      // We have a symbolic constant (ex. propName#OK)
      // We need to retrieve the ValueMap and Values Qualifiers for
      // the property if the exist.
      Uint32 qualIndex = queryPropObj.findQualifier(CIMName("ValueMap"));
   
      if(qualIndex == PEG_NOT_FOUND)
      {
         // This property can not be processed with a symbolic constant.
         throw(Exception(String("CQLValueRep::_resolveSymbolicConstant")));
      }
   
      valueMap = queryPropObj.getQualifier(qualIndex).getValue();
      qualIndex = queryPropObj.findQualifier(CIMName("Values"));
   
      if(qualIndex == PEG_NOT_FOUND)
      {
         // This property does not have a Values Qualifier,
         // therefore the valueMap must be the list of symbolic constants.
   
         valueMap.get(valueMapArray);
   
         // We will loop through the list of Symbolic constants to
         // determine if we have a match with the Symbolic constant
         // defined in the CQLIdentifier.
         for(Uint32 i = 0; i < valueMapArray.size(); ++i)
         {
            if(valueMapArray[i] ==
                 lid.getSymbolicConstantName())
            {
               matchFound = true;
               matchIndex = i;
               break;
            }
         }
         if(matchFound == false)
         {
            // The symbolic constant provided is not valid
            // for this property.
            throw(Exception(String("CQLValueRep::_resolveSymbolicConstant")));
         }
   
         // The symbolic constant defined in the CQLIdentifier is
         // valid for this property. Now we need to set the value.
         // Set primitive
         _setValue(CIMValue(lid.getSymbolicConstantName()));
         return;
      }
      else
      {
         // The qualifier Values is defined for the property.
         // valueMap must be a list of #'s.
   
         values = queryPropObj.getQualifier(qualIndex).getValue();
   
         valueMap.get(valueMapArray);
         values.get(valuesArray);
   
         // We will loop through the list of Symbolic constants to
         // determine if we have a match with the Symbolic constant
         // defined in the CQLIdentifier.
         for(Uint32 i = 0; i < valuesArray.size(); ++i)
         {
            if(valuesArray[i] == lid.getSymbolicConstantName())
            {
               matchFound = true;
               matchIndex = i;
               break;
            }
         }
         if(matchFound == false)
         {
            // The symbolic constant provided is not valid
            // for this property.
            throw(Exception(String("CQLValueRep::_resolveSymbolicConstant")));
         }
   
         CString cStr = valueMapArray[matchIndex].getCString();
         char *endP;
   
         // Set Primitive
         _setValue(CIMValue(Uint64(strtoul((const char*)cStr,&endP,10))));
         return;
      }
   }
   
   PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.1.2.13
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2