1 karl  1.9 //%2006////////////////////////////////////////////////////////////////////////

  2 chuck 1.2 //

  3 karl  1.7 // 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.7 // 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.9 // 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 
 35           #include <Pegasus/Common/InternalException.h>
 36           #include "CQLPredicate.h"
 37           #include "CQLSimplePredicate.h"
 38           #include "CQLPredicateRep.h"
 39           #include <Pegasus/CQL/CQLFactory.h>
 40           #include <Pegasus/Query/QueryCommon/QueryContext.h>

 41 humberto 1.3 #include <Pegasus/Common/Tracer.h>

 42 chuck    1.2 
 43              PEGASUS_NAMESPACE_BEGIN
 44              
 45              CQLPredicateRep::CQLPredicateRep():

 46 karl     1.10     _invert(false)

 47 chuck    1.2  {
 48               
 49               }
 50               

 51 karl     1.10 CQLPredicateRep::CQLPredicateRep(const CQLSimplePredicate& inSimplePredicate,
 52                   Boolean inVerted) :
 53                   _simplePredicate(inSimplePredicate), _invert(inVerted)

 54 chuck    1.2  {

 55 humberto 1.5  

 56 chuck    1.2  }
 57               

 58 karl     1.10 CQLPredicateRep::CQLPredicateRep(const CQLPredicate& inPredicate, 
 59                   Boolean inInverted) :
 60                   _invert(inInverted)

 61 chuck    1.2  {

 62 karl     1.10     _predicates.append(inPredicate);

 63 chuck    1.2  }
 64               
 65               CQLPredicateRep::CQLPredicateRep(const CQLPredicateRep* rep):

 66 karl     1.10     _invert(false)

 67 chuck    1.2  {

 68 karl     1.10     _predicates = rep->_predicates;
 69                   _simplePredicate = rep->_simplePredicate;
 70                   _operators = rep->_operators;
 71                   _invert = rep->_invert;

 72 chuck    1.2  }
 73               
 74               Boolean CQLPredicateRep::evaluate(CIMInstance CI, QueryContext& QueryCtx)
 75               {

 76 karl     1.10     PEG_METHOD_ENTER(TRC_CQL, "CQLIPredicateRep::evaluate");
 77                   Boolean result = false;

 78 humberto 1.5      

 79 karl     1.10     if (isSimple())
 80                   {

 81 chuck    1.2      result = _simplePredicate.evaluate(CI, QueryCtx);

 82 karl     1.10     }
 83                   else
 84                   {
 85                       result = _predicates[0].evaluate(CI, QueryCtx);
 86                       for (Uint32 i = 0; i < _operators.size(); i++)

 87 chuck    1.2          {

 88 karl     1.10             if (_operators[i] == AND)
 89                           {
 90                               if(result)
 91                               {
 92                                   result = _predicates[i+1].evaluate(CI, QueryCtx);
 93                               }
 94                           }
 95                           else
 96                           {
 97                               if(result)
 98                               {
 99                                   break;
100                               }
101                               else
102                               {
103                                   result = _predicates[i+1].evaluate(CI, QueryCtx);
104                               }
105                           }

106 chuck    1.2          }

107 karl     1.10     }
108                   PEG_METHOD_EXIT();
109                   return (getInverted()) ? !result : result;

110 chuck    1.2  }
111               
112               Boolean CQLPredicateRep::getInverted()const{

113 karl     1.10     return _invert;

114 chuck    1.2  }
115               

116 humberto 1.6  void CQLPredicateRep::setInverted(Boolean invert){

117 karl     1.10     _invert = invert;

118 chuck    1.2  }
119               
120               void CQLPredicateRep::appendPredicate(const CQLPredicate& inPredicate){

121 karl     1.10     _predicates.append(inPredicate);

122 chuck    1.2  }
123               

124 karl     1.10 void CQLPredicateRep::appendPredicate(const CQLPredicate& inPredicate,
125                   BooleanOpType inBooleanOperator)

126 chuck    1.2  {

127 karl     1.10     _predicates.append(inPredicate);
128                   _operators.append(inBooleanOperator);

129 chuck    1.2  }
130               
131               Array<CQLPredicate> CQLPredicateRep::getPredicates()const{

132 karl     1.10     return _predicates;

133 chuck    1.2  }
134               
135               CQLSimplePredicate CQLPredicateRep::getSimplePredicate()const{

136 karl     1.10     return _simplePredicate;

137 chuck    1.2  }
138               
139               Array<BooleanOpType> CQLPredicateRep::getOperators()const{

140 karl     1.10     return _operators;

141 chuck    1.2  }
142               

143 vijay.eli 1.8  void CQLPredicateRep::applyContext(const QueryContext& queryContext)

144 chuck     1.2  {

145 karl      1.10     PEG_METHOD_ENTER(TRC_CQL, "CQLPredicateRep::applyContext");
146                    if (isSimple())
147                    {
148                        _simplePredicate.applyContext(queryContext);
149                    }
150                    else

151 chuck     1.2      {

152 karl      1.10         for (Uint32 i = 0; i <_predicates.size(); i++)
153                        {
154                            _predicates[i].applyContext(queryContext);
155                        }

156 chuck     1.2      }

157 karl      1.10     PEG_METHOD_EXIT();

158 chuck     1.2  }
159                
160                Boolean CQLPredicateRep::isSimple()const{

161 karl      1.10     return (_predicates.size() == 0);

162 chuck     1.2  }
163                
164                Boolean CQLPredicateRep::isSimpleValue()const{

165 karl      1.10     return (isSimple() && _simplePredicate.isSimpleValue());

166 chuck     1.2  }
167                
168                String CQLPredicateRep::toString()const{

169 karl      1.10     if(isSimple())
170                    {
171                        String s;

172 humberto  1.5        if(_invert) s = "NOT ";
173                      s.append(_simplePredicate.toString());
174                      return s;

175 karl      1.10     }
176                    String s;
177                    if(_invert) s = "NOT ";
178                    for(Uint32 i = 0; i < _predicates.size(); i++)
179                    {
180                        s.append(_predicates[i].toString());
181                        if(i < _operators.size())
182                        {
183                            switch(_operators[i])
184                            {
185                                case AND: s.append(" AND ");
186                                    break;
187                                case OR: s.append(" OR ");
188                                    break;
189                            }
190                        }
191                    }
192                    return s;

193 chuck     1.2  }
194                
195                PEGASUS_NAMESPACE_END