(file) Return to CQLTermRep.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / CQL 
  1 karl  1.8 //%2006////////////////////////////////////////////////////////////////////////

  2 chuck 1.2 //

  3 karl  1.5 // 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.5 // 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.8 // 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           
 34 chuck 1.2 #include <Pegasus/CQL/CQLTerm.h>
 35           #include <Pegasus/CQL/CQLTermRep.h>
 36           #include <Pegasus/CQL/CQLFactory.h>
 37           #include <Pegasus/Query/QueryCommon/QueryContext.h>
 38           #include <Pegasus/Query/QueryCommon/QueryException.h>
 39           #include <Pegasus/Common/Tracer.h>
 40           
 41           PEGASUS_NAMESPACE_BEGIN
 42           
 43           CQLTermRep::CQLTermRep(){}
 44           
 45           CQLTermRep::CQLTermRep(const CQLFactor& theFactor)
 46           {

 47 karl  1.9     PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep:CQLTermRep()");
 48               
 49               _Factors.append(theFactor);
 50               
 51               PEG_METHOD_EXIT();

 52 chuck 1.2 }
 53           
 54           CQLTermRep::CQLTermRep(const CQLTermRep& rep){

 55 karl  1.9     _Factors = rep._Factors;
 56               _FactorOperators = rep._FactorOperators;

 57 chuck 1.2 }
 58           
 59           CQLTermRep::~CQLTermRep(){
 60           }
 61           

 62 karl  1.9 CQLValue CQLTermRep::resolveValue(const CIMInstance& CI,
 63                                             const QueryContext& QueryCtx)

 64 chuck 1.2 {

 65 karl  1.9     PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep:resolveValue()");
 66               CQLValue returnVal = _Factors[0].resolveValue(CI,QueryCtx);
 67               
 68               for(Uint32 i = 0; i < _FactorOperators.size(); ++i)
 69               {
 70                   switch(_FactorOperators[i])
 71                   {
 72                        /*
 73                        case mult:
 74                           returnVal = returnVal * 
 75                                       _Factors[i+1].resolveValue(CI,QueryCtx);
 76                           break;
 77                        case divide:
 78                           returnVal = returnVal / 
 79                                       _Factors[i+1].resolveValue(CI,QueryCtx);
 80                           break;
 81                       */
 82                        case concat:
 83                           returnVal = returnVal + 
 84                                       _Factors[i+1].resolveValue(CI,QueryCtx);
 85                           break;
 86 karl  1.9             
 87                        default:
 88                          MessageLoaderParms mload(
 89                              String("CQL.CQLTermRep.OPERATION_NOT_SUPPORTED"),
 90                              String("Operation is not supported."));
 91                          throw CQLRuntimeException(mload);
 92                   }
 93               }
 94               
 95               PEG_METHOD_EXIT();
 96               return returnVal;

 97 chuck 1.2 }
 98           

 99 karl  1.9 void CQLTermRep::appendOperation(FactorOpType inFactorOpType,
100                                            const CQLFactor& inFactor)
101           {
102               PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep::appendOperation()");
103               
104               _FactorOperators.append(inFactorOpType);
105               _Factors.append(inFactor);
106               
107               PEG_METHOD_EXIT();

108 chuck 1.2 }
109           
110           String CQLTermRep::toString()const
111           {

112 karl  1.9     PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep::toString()");
113               
114               String returnStr;
115               
116               returnStr.append(_Factors[0].toString());
117               
118               for(Uint32 i = 0; i < _FactorOperators.size(); ++i)

119 chuck 1.2     {

120 karl  1.9         /*
121                   returnStr.append(_FactorOperators[i] == 
122                          mult ? String(" * ") : divide ? String(" / ")
123                          : String(" concat "));
124                   */
125                   if(_FactorOperators[i] == concat)
126                       returnStr.append(String(" || "));
127                   returnStr.append(_Factors[i+1].toString());

128 chuck 1.2     }

129 karl  1.9     
130               PEG_METHOD_EXIT();
131               return returnStr;

132 chuck 1.2 }
133           
134           Boolean CQLTermRep::isSimple()const
135           {

136 karl  1.9     return (_Factors.size() == 1);

137 chuck 1.2 }
138           
139           Boolean CQLTermRep::isSimpleValue()const
140           {

141 karl  1.9     PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep::isSimpleValue()");
142               if(_Factors.size() == 1) 

143 chuck 1.2     {

144 karl  1.9         PEG_METHOD_EXIT();
145                   return _Factors[0].isSimpleValue();

146 chuck 1.2     }   

147 karl  1.9     
148               PEG_METHOD_EXIT();
149               return false;

150 chuck 1.2 }
151           
152           Array<CQLFactor> CQLTermRep::getFactors()const
153           {

154 karl  1.9     return _Factors;

155 chuck 1.2 }
156           
157           Array<FactorOpType> CQLTermRep::getOperators()const
158           {

159 karl  1.9     return _FactorOperators;

160 chuck 1.2 }
161           

162 vijay.eli 1.6 void CQLTermRep::applyContext(const QueryContext& inContext,
163                                             const CQLChainedIdentifier& inCid)

164 chuck     1.2 {

165 karl      1.9     PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep::applyContext()");
166                   
167                   for(Uint32 i = 0; i < _Factors.size(); ++i)

168 chuck     1.2     {

169 karl      1.9         _Factors[i].applyContext(inContext, inCid);

170 chuck     1.2     }

171 karl      1.9     
172                   PEG_METHOD_EXIT();

173 chuck     1.2 }

174 humberto  1.4 /*

175 chuck     1.2 Boolean CQLTermRep::operator==(const CQLTermRep& rhs)const
176               {
177                 PEG_METHOD_ENTER(TRC_CQL,"CQLTermRep::operator==()");
178                 
179                 for(Uint32 i = 0; i < _FactorOperators.size(); ++i)
180                   {
181                     if(_FactorOperators[i] != rhs._FactorOperators[i])

182 karl      1.9     {
183                     PEG_METHOD_EXIT();
184                     return false;
185                   }

186 chuck     1.2     }
187                 
188                 for(Uint32 i = 0; i < _Factors.size(); ++i)
189                   {
190                     if(_Factors[i] != rhs._Factors[i])

191 karl      1.9     {
192                     PEG_METHOD_EXIT();
193                     return false;
194                   }

195 chuck     1.2     }
196                 
197                 PEG_METHOD_EXIT();
198                 return true;
199               }
200               
201               Boolean CQLTermRep::operator!=(const CQLTermRep& rhs)const
202               {
203                 return (!operator==(rhs));
204               }

205 humberto  1.4 */

206 chuck     1.2 PEGASUS_NAMESPACE_END
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2