1 karl 1.14 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.8 // 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 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.8 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.11 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.14 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
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 karl 1.8 //
|
21 schuur 1.1 // 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
|
35 schuur 1.6 #include "CMPI_Version.h"
|
36 schuur 1.1
37 #include <Pegasus/Common/Stack.h>
38 #include <Pegasus/WQL/WQLParser.h>
|
39 chuck 1.9 #include <Pegasus/WQL/WQLSelectStatementRep.h>
|
40 ms.aruran 1.18 #include <Pegasus/Common/Tracer.h>
|
41 schuur 1.1
42 #include "CMPI_Wql2Dnf.h"
43
|
44 schuur 1.4 PEGASUS_USING_STD;
|
45 schuur 1.1 PEGASUS_NAMESPACE_BEGIN
46
47 //
48 // Terminal element methods
49 //
|
50 konrad.r 1.10 void term_el_WQL::negate(void)
|
51 schuur 1.1 {
|
52 venkat.puvvada 1.17 switch( op )
|
53 schuur 1.1 {
|
54 venkat.puvvada 1.17 case WQL_EQ: op = WQL_NE;
55 break;
56 case WQL_NE: op = WQL_EQ;
57 break;
58 case WQL_LT: op = WQL_GE;
59 break;
60 case WQL_LE: op = WQL_GT;
61 break;
62 case WQL_GT: op = WQL_LE;
63 break;
64 case WQL_GE: op = WQL_LT;
65 break;
66 default:
67 break;
|
68 schuur 1.1 }
69 };
|
70 mike 1.16
|
71 schuur 1.1 static bool operator==(const WQLOperand& x, const WQLOperand& y)
72 {
|
73 venkat.puvvada 1.17 if( x.getType()==y.getType() )
74 {
75 switch( x.getType() )
76 {
77 case WQLOperand::PROPERTY_NAME:
78 return x.getPropertyName()==y.getPropertyName();
79 case WQLOperand::INTEGER_VALUE:
80 return x.getIntegerValue()==y.getIntegerValue();
81 case WQLOperand::DOUBLE_VALUE:
82 return x.getDoubleValue()==y.getDoubleValue();
83 case WQLOperand::BOOLEAN_VALUE:
84 return x.getBooleanValue()==y.getBooleanValue();
85 case WQLOperand::STRING_VALUE:
86 return x.getStringValue()==y.getStringValue();
87 case WQLOperand::NULL_VALUE:
88 return true;
89 }
90 }
91 return false;
|
92 schuur 1.1 }
93
|
94 konrad.r 1.10 static bool operator==(const term_el_WQL& x, const term_el_WQL& y)
|
95 schuur 1.1 {
|
96 venkat.puvvada 1.17 return x.op == y.op &&
97 x.opn1 == y.opn1 &&
98 x.opn2 == y.opn2;
|
99 schuur 1.1 }
100
|
101 konrad.r 1.10 static void addIfNotExists(TableauRow_WQL &tr, const term_el_WQL& el)
|
102 schuur 1.1 {
|
103 ms.aruran 1.18 PEG_METHOD_ENTER(
104 TRC_CMPIPROVIDERINTERFACE,
105 "CMPI_Wql2Dnf:addIfNotExists()");
|
106 venkat.puvvada 1.17 for( int i=0,m=tr.size(); i<m; i++ )
107 {
108 if( tr[i]==el )
109 {
|
110 ms.aruran 1.18 PEG_METHOD_EXIT();
|
111 venkat.puvvada 1.17 return;
112 }
113 }
114 tr.append(el);
|
115 ms.aruran 1.18 PEG_METHOD_EXIT();
|
116 schuur 1.1 }
117
|
118 konrad.r 1.10 CMPI_Wql2Dnf::CMPI_Wql2Dnf(const String &condition, const String &pref)
|
119 schuur 1.1 {
120 WQLSelectStatement wqs;
121 WQLParser::parse(pref+condition,wqs);
122 eval_heap.reserveCapacity(16);
123 terminal_heap.reserveCapacity(16);
124 _tableau.clear();
125 compile(&wqs);
126 }
127
128 CMPI_Wql2Dnf::CMPI_Wql2Dnf()
129 {
130 eval_heap.reserveCapacity(16);
131 terminal_heap.reserveCapacity(16);
132 _tableau.clear();
133 }
134
|
135 venkat.puvvada 1.17 CMPI_Wql2Dnf::~CMPI_Wql2Dnf()
136 {
137 }
|
138 schuur 1.1
139 void CMPI_Wql2Dnf::compile(const WQLSelectStatement * wqs)
140 {
|
141 ms.aruran 1.18 PEG_METHOD_ENTER(TRC_CMPIPROVIDERINTERFACE, "CMPI_Wql2Dnf::compile()");
|
142 venkat.puvvada 1.17 if( !wqs->hasWhereClause() )
143 {
|
144 ms.aruran 1.18 PEG_METHOD_EXIT();
|
145 venkat.puvvada 1.17 return;
146 }
|
147 schuur 1.1 _tableau.clear();
148
149 _buildEvalHeap(wqs);
150 _pushNOTDown();
151 _factoring();
|
152 venkat.puvvada 1.17
|
153 mike 1.16 Array<CMPI_stack_el> disj;
|
154 schuur 1.1 _gatherDisj(disj);
|
155 venkat.puvvada 1.17 if( disj.size() == 0 )
156 {
157 if( terminal_heap.size() > 0 )
158 {
159 // point to the remaining terminal element
|
160 mike 1.16 disj.append(CMPI_stack_el(0,true));
|
161 venkat.puvvada 1.17 }
162 }
|
163 schuur 1.1
|
164 venkat.puvvada 1.17 for( Uint32 i=0, n =disj.size(); i< n; i++ )
|
165 schuur 1.1 {
|
166 konrad.r 1.10 TableauRow_WQL tr;
|
167 mike 1.16 Array<CMPI_stack_el> conj;
|
168 schuur 1.1
|
169 venkat.puvvada 1.17 if( !disj[i].is_terminal )
|
170 schuur 1.1 {
|
171 venkat.puvvada 1.17 _gatherConj(conj, disj[i]);
172 for( Uint32 j=0, m = conj.size(); j < m; j++ )
173 {
174 addIfNotExists(tr,terminal_heap[conj[j].opn]);
175 // tr.append(terminal_heap[conj[j].opn]);
176 }
|
177 schuur 1.1 }
178 else
|
179 venkat.puvvada 1.17 {
180 addIfNotExists(tr,terminal_heap[disj[i].opn]);
181 // tr.append(terminal_heap[disj[i].opn]);
182 }
|
183 schuur 1.1 _tableau.append(tr);
184 }
185
186 eval_heap.clear();
|
187 venkat.puvvada 1.17
188 _populateTableau();
|
189 ms.aruran 1.18 PEG_METHOD_EXIT();
|
190 schuur 1.1 }
191
|
192 venkat.puvvada 1.17 String WQL2String(const WQLOperand &o)
193 {
194 switch( o.getType() )
195 {
196 case WQLOperand::PROPERTY_NAME:
197 return o.getPropertyName();
198 case WQLOperand::STRING_VALUE:
199 return o.getStringValue();
200 case WQLOperand::INTEGER_VALUE:
201 return Formatter::format("$0",o.getIntegerValue());
202 case WQLOperand::DOUBLE_VALUE:
203 return Formatter::format("$0",o.getDoubleValue());
204 case WQLOperand::BOOLEAN_VALUE:
205 return Formatter::format("$0",o.getBooleanValue());
206 default: ;
207 }
208 return "NULL_VALUE";
|
209 konrad.r 1.10 }
210
|
211 venkat.puvvada 1.17 CMPIPredOp WQL2PredOp(const WQLOperation &op)
212 {
|
213 ms.aruran 1.18 PEG_METHOD_ENTER(TRC_CMPIPROVIDERINTERFACE,"CMPI_Wql2Dnf:WQL2PredOp()");
|
214 venkat.puvvada 1.17 static CMPIPredOp ops[]={(CMPIPredOp)0,(CMPIPredOp)0,(CMPIPredOp)0,
215 CMPI_PredOp_Equals,
216 CMPI_PredOp_NotEquals,
217 CMPI_PredOp_LessThan,
218 CMPI_PredOp_LessThanOrEquals,
219 CMPI_PredOp_GreaterThan,
220 CMPI_PredOp_GreaterThanOrEquals,
221 (CMPIPredOp)0,(CMPIPredOp)0,(CMPIPredOp)0,
222 (CMPIPredOp)0,(CMPIPredOp)0,(CMPIPredOp)0};
|
223 ms.aruran 1.18 PEG_METHOD_EXIT();
|
224 venkat.puvvada 1.17 return ops[(int)op];
|
225 konrad.r 1.10 }
226
|
227 venkat.puvvada 1.17 CMPI_QueryOperand::Type WQL2Type(WQLOperand::Type typ)
228 {
229 switch( typ )
230 {
231 case WQLOperand::PROPERTY_NAME:
232 return CMPI_QueryOperand::PROPERTY_TYPE;
233 case WQLOperand::STRING_VALUE:
234 return CMPI_QueryOperand::STRING_TYPE;
235 case WQLOperand::INTEGER_VALUE:
236 return CMPI_QueryOperand::UINT64_TYPE;
237 case WQLOperand::DOUBLE_VALUE:
238 return CMPI_QueryOperand::REAL_TYPE;
239 case WQLOperand::BOOLEAN_VALUE:
240 return CMPI_QueryOperand::BOOLEAN_TYPE;
241 case WQLOperand::NULL_VALUE:
242 return CMPI_QueryOperand::NULL_TYPE;
243 }
244 return CMPI_QueryOperand::NULL_TYPE;
|
245 konrad.r 1.10 }
246
247
248 void CMPI_Wql2Dnf::_populateTableau(void)
249 {
|
250 ms.aruran 1.18 PEG_METHOD_ENTER(
251 TRC_CMPIPROVIDERINTERFACE,
252 "CMPI_Wql2Dnf::_populateTableau()");
|
253 venkat.puvvada 1.17 for( Uint32 i=0,n = _tableau.size(); i < n; i++ )
254 {
255 TableauRow_WQL tr_wql = _tableau[i];
256
257 for( Uint32 j=0,m = tr_wql.size(); j < m; j++ )
258 {
259 term_el_WQL t = tr_wql[j];
|
260 konrad.r 1.10
|
261 venkat.puvvada 1.17 CMPI_TableauRow tr;
262 CMPI_QueryOperand lhs(WQL2String(t.opn1),
263 WQL2Type(t.opn1.getType()));
264 CMPI_QueryOperand rhs(WQL2String(t.opn2),
265 WQL2Type(t.opn2.getType()));
|
266 konrad.r 1.10
|
267 venkat.puvvada 1.17 tr.append(CMPI_term_el(t.mark, WQL2PredOp(t.op), lhs, rhs));
268 _CMPI_tableau.append (tr);
|
269 konrad.r 1.10
|
270 venkat.puvvada 1.17 }
271
272 }
|
273 ms.aruran 1.18 PEG_METHOD_EXIT();
|
274 konrad.r 1.10 }
|
275 schuur 1.1 void CMPI_Wql2Dnf::_buildEvalHeap(const WQLSelectStatement * wqs)
276 {
|
277 ms.aruran 1.18 PEG_METHOD_ENTER(
278 TRC_CMPIPROVIDERINTERFACE,
279 "CMPI_Wql2Dnf::_buildEvalHeap()");
|
280 schuur 1.1 //WQLSelectStatement* that = (WQLSelectStatement*)wqs;
281
|
282 chuck 1.9 WQLSelectStatementRep* wqsrep = wqs->_rep;
283
|
284 schuur 1.1 WQLOperand dummy;
285 dummy.clear();
|
286 mike 1.16 Stack<CMPI_stack_el> stack;
|
287 schuur 1.3
|
288 schuur 1.1 // Counter for Operands
289
290 Uint32 j = 0;
291
292 //cerr << "Build eval heap\n";
293
|
294 venkat.puvvada 1.17 for( Uint32 i = 0, n = wqsrep->_operations.size(); i < n; i++ )
|
295 schuur 1.1 {
|
296 chuck 1.9 WQLOperation op = wqsrep->_operations[i];
|
297 schuur 1.1
|
298 venkat.puvvada 1.17 switch( op )
|
299 schuur 1.1 {
300 case WQL_OR:
301 case WQL_AND:
|
302 venkat.puvvada 1.17 {
303 PEGASUS_ASSERT(stack.size() >= 2);
|
304 schuur 1.1
|
305 venkat.puvvada 1.17 CMPI_stack_el op1 = stack.top();
306 stack.pop();
|
307 schuur 1.1
|
308 venkat.puvvada 1.17 CMPI_stack_el op2 = stack.top();
|
309 schuur 1.1
|
310 venkat.puvvada 1.17 // generate Eval expression
311 eval_heap.append(CMPI_eval_el(
312 0, op , op1.opn,
313 op1.is_terminal,op2.opn ,
314 op2.is_terminal));
|
315 schuur 1.1
|
316 venkat.puvvada 1.17 stack.top() = CMPI_stack_el(eval_heap.size()-1, false);
|
317 schuur 1.1
|
318 venkat.puvvada 1.17 break;
319 }
|
320 schuur 1.1
321 case WQL_NOT:
322 case WQL_IS_FALSE:
323 case WQL_IS_NOT_TRUE:
|
324 venkat.puvvada 1.17 {
325 PEGASUS_ASSERT(stack.size() >= 1);
|
326 schuur 1.1
|
327 venkat.puvvada 1.17 CMPI_stack_el op1 = stack.top();
|
328 schuur 1.1
|
329 venkat.puvvada 1.17 // generate Eval expression
330 eval_heap.append(CMPI_eval_el(
331 0, op , op1.opn,
332 op1.is_terminal,-1, true));
|
333 schuur 1.1
|
334 venkat.puvvada 1.17 stack.top() = CMPI_stack_el(eval_heap.size()-1, false);
|
335 schuur 1.1
|
336 venkat.puvvada 1.17 break;
337 }
|
338 schuur 1.1
339 case WQL_EQ:
340 case WQL_NE:
341 case WQL_LT:
342 case WQL_LE:
343 case WQL_GT:
344 case WQL_GE:
|
345 venkat.puvvada 1.17 {
346 PEGASUS_ASSERT(wqsrep->_operands.size() >= 2);
|
347 schuur 1.1
|
348 venkat.puvvada 1.17 WQLOperand lhs = wqsrep->_operands[j++];
|
349 schuur 1.1
|
350 venkat.puvvada 1.17 WQLOperand rhs = wqsrep->_operands[j++];
|
351 schuur 1.1
|
352 venkat.puvvada 1.17 terminal_heap.push(term_el_WQL(false, op, lhs, rhs));
|
353 schuur 1.1
|
354 venkat.puvvada 1.17 stack.push(CMPI_stack_el(terminal_heap.size()-1, true));
|
355 schuur 1.1
|
356 venkat.puvvada 1.17 break;
357 }
|
358 schuur 1.1
359 case WQL_IS_TRUE:
360 case WQL_IS_NOT_FALSE:
|
361 venkat.puvvada 1.17 {
362 PEGASUS_ASSERT(stack.size() >= 1);
363 break;
364 }
|
365 schuur 1.1
366 case WQL_IS_NULL:
|
367 venkat.puvvada 1.17 {
368 PEGASUS_ASSERT(wqsrep->_operands.size() >= 1);
369 WQLOperand op = wqsrep->_operands[j++];
|
370 schuur 1.1
|
371 venkat.puvvada 1.17 terminal_heap.push(term_el_WQL(false, WQL_EQ, op, dummy));
|
372 schuur 1.1
|
373 venkat.puvvada 1.17 stack.push(CMPI_stack_el(terminal_heap.size()-1, true));
|
374 schuur 1.1
|
375 venkat.puvvada 1.17 break;
376 }
|
377 schuur 1.1
378 case WQL_IS_NOT_NULL:
|
379 venkat.puvvada 1.17 {
380 PEGASUS_ASSERT(wqsrep->_operands.size() >= 1);
381 WQLOperand op = wqsrep->_operands[j++];
|
382 schuur 1.1
|
383 venkat.puvvada 1.17 terminal_heap.push(term_el_WQL(false, WQL_NE, op, dummy));
|
384 schuur 1.1
|
385 venkat.puvvada 1.17 stack.push(CMPI_stack_el(terminal_heap.size()-1, true));
|
386 schuur 1.1
|
387 venkat.puvvada 1.17 break;
388 }
|
389 schuur 1.1 }
390 }
391
392 PEGASUS_ASSERT(stack.size() == 1);
|
393 ms.aruran 1.18 PEG_METHOD_EXIT();
|
394 schuur 1.1 }
395
396 void CMPI_Wql2Dnf::_pushNOTDown()
397 {
|
398 ms.aruran 1.18 PEG_METHOD_ENTER(
399 TRC_CMPIPROVIDERINTERFACE,
400 "CMPI_Wql2Dnf::_pushNOTDown()");
|
401 venkat.puvvada 1.17 for( int i=eval_heap.size()-1; i >= 0; i-- )
|
402 schuur 1.1 {
403 Boolean _found = false;
404
405 // Order all operators, so that op1 > op2 for non-terminals
406 // and terminals appear as second operand
407
408 eval_heap[i].order();
409
410 // First solve the unary NOT operator
411
|
412 venkat.puvvada 1.17 if( eval_heap[i].op == WQL_NOT ||
413 eval_heap[i].op == WQL_IS_FALSE ||
414 eval_heap[i].op == WQL_IS_NOT_TRUE )
415 {
|
416 schuur 1.1 // This serves as the equivalent of an empty operator
417 eval_heap[i].op = WQL_IS_TRUE;
418
419 // Substitute this expression in all higher order eval statements
420 // so that this node becomes disconnected from the tree
421
|
422 venkat.puvvada 1.17 for( int j=eval_heap.size()-1; j > i;j-- )
|
423 schuur 1.1 {
|
424 venkat.puvvada 1.17 // Test first operand
425 if( (!eval_heap[j].is_terminal1) && (eval_heap[j].opn1 == i) )
426 {
427
428 eval_heap[j].assign_unary_to_first(eval_heap[i]);
429 }
430
431 // Test second operand
432 if( (!eval_heap[j].is_terminal2) && (eval_heap[j].opn2 == i) )
433 {
|
434 schuur 1.1
|
435 venkat.puvvada 1.17 eval_heap[j].assign_unary_to_second(eval_heap[i]);
436 }
|
437 schuur 1.1 }
438
439 // Test: Double NOT created by moving down
440
|
441 venkat.puvvada 1.17 if( eval_heap[i].mark )
442 {
443 eval_heap[i].mark = false;
444 }
|
445 schuur 1.1 else
|
446 venkat.puvvada 1.17 {
447 _found = true;
448 }
|
449 schuur 1.1 // else indicate a pending NOT to be pushed down further
450 }
451
452 // Simple NOT created by moving down
453
|
454 venkat.puvvada 1.17 if( eval_heap[i].mark )
|
455 schuur 1.1 {
456 // Remove the mark, indicate a pending NOT to be pushed down
457 // further and switch operators (AND / OR)
458
459 eval_heap[i].mark=false;
|
460 venkat.puvvada 1.17 if( eval_heap[i].op == WQL_OR )
461 {
462 eval_heap[i].op = WQL_AND;
463 }
464 else
465 {
466 if( eval_heap[i].op == WQL_AND )
467 {
468 eval_heap[i].op = WQL_OR;
469 }
470 }
|
471 schuur 1.1
472 // NOT operator is already ruled out
473 _found = true;
474 }
475
476 // Push a pending NOT further down
|
477 venkat.puvvada 1.17 if( _found )
|
478 schuur 1.1 {
|
479 venkat.puvvada 1.17 // First operand
|
480 schuur 1.1
|
481 venkat.puvvada 1.17 int j = eval_heap[i].opn1;
482 if( eval_heap[i].is_terminal1 )
483 {
484 // Flip NOT mark
485 terminal_heap[j].negate();
486 }
487 else
488 {
489 eval_heap[j].mark = !(eval_heap[j].mark);
490 }
491
492 //Second operand (if it exists)
493
494 if( (j = eval_heap[i].opn2) >= 0 )
495 {
496 if( eval_heap[i].is_terminal2 )
497 {
498 // Flip NOT mark
499 terminal_heap[j].negate();
500 }
501 else
502 venkat.puvvada 1.17 {
503 eval_heap[j].mark = !(eval_heap[j].mark);
504 }
505 }
|
506 schuur 1.1 }
507 }
|
508 ms.aruran 1.18 PEG_METHOD_EXIT();
|
509 schuur 1.1 }
510
511 void CMPI_Wql2Dnf::_factoring(void)
512 {
|
513 ms.aruran 1.18 PEG_METHOD_ENTER(TRC_CMPIPROVIDERINTERFACE, "CMPI_Wql2Dnf::_factoring()");
|
514 schuur 1.1 int i = 0,n = eval_heap.size();
515 //for (int i=eval_heap.size()-1; i >= 0; i--)
|
516 venkat.puvvada 1.17 while( i < n )
|
517 schuur 1.1 {
518 int _found = 0;
519 int index = 0;
520
521 // look for expressions (A | B) & C ---> A & C | A & B
|
522 venkat.puvvada 1.17 if( eval_heap[i].op == WQL_AND )
|
523 schuur 1.1 {
|
524 venkat.puvvada 1.17 if( !eval_heap[i].is_terminal1 )
|
525 schuur 1.1 {
526 index = eval_heap[i].opn1; // remember the index
|
527 venkat.puvvada 1.17 if( eval_heap[index].op == WQL_OR )
528 {
529 _found = 1;
530 }
|
531 ks.madhusudan 1.20 }
532 if( (_found == 0) && (!eval_heap[i].is_terminal2) )
533 {
|
534 venkat.puvvada 1.17 index = eval_heap[i].opn2; // remember the index
535 if( eval_heap[index].op == WQL_OR )
536 {
537 _found = 2;
538 }
|
539 ks.madhusudan 1.20 }
540
541 if( _found != 0 )
542 {
543 //int u1,u1_t,u2,u2_t,u3,u3_t;
544 CMPI_stack_el s;
545
546 if( _found == 1 )
547 {
548 s = eval_heap[i].getSecond();
|
549 venkat.puvvada 1.17 }
|
550 ks.madhusudan 1.20 else
|
551 venkat.puvvada 1.17 {
|
552 ks.madhusudan 1.20 s = eval_heap[i].getFirst();
553 }
|
554 venkat.puvvada 1.17
|
555 ks.madhusudan 1.20 // insert two new expression before entry i
556 CMPI_eval_el evl;
|
557 venkat.puvvada 1.17
|
558 ks.madhusudan 1.20 evl = CMPI_eval_el(false, WQL_OR, i+1, false, i, false);
559 if( (Uint32 )i < eval_heap.size()-1 )
560 {
|
561 venkat.puvvada 1.17 eval_heap.insert(i+1, evl);
|
562 ks.madhusudan 1.20 }
563 else
564 {
565 eval_heap.append(evl);
566 }
567 eval_heap.insert(i+1, evl);
|
568 venkat.puvvada 1.17
|
569 ks.madhusudan 1.20 for( int j=eval_heap.size()-1; j > i + 2; j-- )
570 {
571 //eval_heap[j] = eval_heap[j-2];
|
572 venkat.puvvada 1.17
|
573 ks.madhusudan 1.20 // adjust pointers
|
574 venkat.puvvada 1.17
|
575 ks.madhusudan 1.20 if( (!eval_heap[j].is_terminal1)&&
|
576 venkat.puvvada 1.17 (eval_heap[j].opn1 >= i) )
|
577 ks.madhusudan 1.20 {
578 eval_heap[j].opn1 += 2;
579 }
580 if( (!eval_heap[j].is_terminal2)&&
|
581 venkat.puvvada 1.17 (eval_heap[j].opn2 >= i) )
|
582 ks.madhusudan 1.20 {
583 eval_heap[j].opn2 += 2;
|
584 venkat.puvvada 1.17 }
|
585 ks.madhusudan 1.20 }
|
586 venkat.puvvada 1.17
|
587 ks.madhusudan 1.20 n+=2; // increase size of array
|
588 venkat.puvvada 1.17
|
589 ks.madhusudan 1.20 // generate the new expressions : new OR expression
|
590 venkat.puvvada 1.17
|
591 ks.madhusudan 1.20 // first new AND expression
592 eval_heap[i+1].mark = false;
593 eval_heap[i+1].op = WQL_AND;
594 eval_heap[i+1].setFirst(s);
595 eval_heap[i+1].setSecond( eval_heap[index].getFirst());
596 eval_heap[i+1].order();
597
598 // second new AND expression
599 eval_heap[i].mark = false;
600 eval_heap[i].op = WQL_AND;
601 eval_heap[i].setFirst(s);
602 eval_heap[i].setSecond( eval_heap[index].getSecond());
603 eval_heap[i].order();
604
605 // mark the indexed expression as inactive
606 //eval_heap[index].op = WQL_IS_TRUE; possible disconnects
607 i--;
608
609 } /* endif _found > 0 */
610
611 } /* endif found AND operator */
612 ks.madhusudan 1.20
613 i++; // increase pointer
614 } // end of while loop
615
|
616 ms.aruran 1.18 PEG_METHOD_EXIT();
|
617 schuur 1.1 }
|
618 venkat.puvvada 1.17 void CMPI_Wql2Dnf::_gatherDisj(Array<CMPI_stack_el>& stk)
619 {
620 _gather(stk, CMPI_stack_el(0,true), true);
621 }
|
622 schuur 1.1
|
623 venkat.puvvada 1.17 void CMPI_Wql2Dnf::_gatherConj(
624 Array<CMPI_stack_el>& stk,
625 CMPI_stack_el sel)
|
626 schuur 1.1 {
|
627 venkat.puvvada 1.17 _gather(stk, sel, false);
|
628 schuur 1.1 }
629
|
630 venkat.puvvada 1.17 void CMPI_Wql2Dnf::_gather(
631 Array<CMPI_stack_el>& stk,
632 CMPI_stack_el sel,
633 Boolean or_flag)
|
634 schuur 1.1 {
|
635 ms.aruran 1.18 PEG_METHOD_ENTER(TRC_CMPIPROVIDERINTERFACE, "CMPI_Wql2Dnf::_gather()");
|
636 venkat.puvvada 1.17 Uint32 i = 0;
637
638 stk.clear();
639 stk.reserveCapacity(16);
|
640 schuur 1.1
|
641 venkat.puvvada 1.17 if( (i = eval_heap.size()) == 0 )
642 {
|
643 ms.aruran 1.18 PEG_METHOD_EXIT();
|
644 venkat.puvvada 1.17 return;
645 }
|
646 schuur 1.1
|
647 venkat.puvvada 1.17 while( eval_heap[i-1].op == WQL_IS_TRUE )
648 {
649 eval_heap.remove(i-1);
650 i--;
651 if( i == 0 )
652 {
|
653 ms.aruran 1.18 PEG_METHOD_EXIT();
|
654 venkat.puvvada 1.17 return;
655 }
656 }
657 //if (i == 0) return;
|
658 schuur 1.1
|
659 venkat.puvvada 1.17 if( or_flag )
660 {
661 stk.append(CMPI_stack_el(i-1,false));
662 }
|
663 schuur 1.1 else
664 {
|
665 venkat.puvvada 1.17 if( sel.is_terminal )
666 {
|
667 ms.aruran 1.18 PEG_METHOD_EXIT();
|
668 venkat.puvvada 1.17 return;
669 }
670 stk.append(sel);
671 }
672
673 i = 0;
674
675 while( i<stk.size() )
676 {
677 int k = stk[i].opn;
678
679 if( (k < 0) || (stk[i].is_terminal) )
680 {
|
681 schuur 1.3 i++;
|
682 venkat.puvvada 1.17 }
|
683 schuur 1.1 else
684 {
|
685 venkat.puvvada 1.17 if ( ((eval_heap[k].op != WQL_OR) && (or_flag)) ||
686 ((eval_heap[k].op != WQL_AND) && (!or_flag)) )
687 {
688 i++;
689 }
690 else
691 {
692 // replace the element with disjunction
693 stk[i] = eval_heap[k].getSecond();
694 stk.insert(i, eval_heap[k].getFirst());
695 if (or_flag)
696 {
697 eval_heap[k].op = WQL_IS_TRUE;
698 }
699 }
|
700 schuur 1.1 }
701 }
|
702 ms.aruran 1.18 PEG_METHOD_EXIT();
|
703 schuur 1.1 }
704
|
705 venkat.puvvada 1.17 //=============================================================================
|
706 mike 1.16 //
707 // class CMPI_stack_el
708 //
|
709 venkat.puvvada 1.17 //=============================================================================
|
710 mike 1.16
|
711 venkat.puvvada 1.17 //=============================================================================
|
712 mike 1.16 //
713 // class CMPI_eval_el
714 //
|
715 venkat.puvvada 1.17 //=============================================================================
|
716 mike 1.16
|
717 venkat.puvvada 1.17 CMPI_stack_el CMPI_eval_el::getFirst()
718 {
719 return CMPI_stack_el(opn1, is_terminal1);
720 }
|
721 mike 1.16
|
722 venkat.puvvada 1.17 CMPI_stack_el CMPI_eval_el::getSecond()
723 {
724 return CMPI_stack_el(opn2, is_terminal2);
725 }
|
726 mike 1.16
|
727 venkat.puvvada 1.17 void CMPI_eval_el::setFirst(const CMPI_stack_el s)
728 {
729 opn1 = s.opn;
730 is_terminal1 = s.is_terminal;
731 }
|
732 mike 1.16
|
733 venkat.puvvada 1.17 void CMPI_eval_el::setSecond(const CMPI_stack_el s)
734 {
735 opn2 = s.opn;
736 is_terminal2 = s.is_terminal;
737 }
|
738 mike 1.16
|
739 venkat.puvvada 1.17 void CMPI_eval_el::assign_unary_to_first(const CMPI_eval_el & assignee)
740 {
741 opn1 = assignee.opn1;
742 is_terminal1 = assignee.is_terminal1;
743 }
|
744 mike 1.16
|
745 venkat.puvvada 1.17 void CMPI_eval_el::assign_unary_to_second(const CMPI_eval_el & assignee)
746 {
747 opn2 = assignee.opn1;
748 is_terminal2 = assignee.is_terminal1;
749 }
|
750 mike 1.16
751 // Ordering operators, so that op1 > op2 for all non-terminals
752 // and terminals appear in the second operand first
753 void CMPI_eval_el::order(void)
754 {
|
755 ms.aruran 1.18 PEG_METHOD_ENTER(TRC_CMPIPROVIDERINTERFACE, "CMPI_eval_el::order()");
|
756 mike 1.16 int k;
|
757 venkat.puvvada 1.17 if( (!is_terminal1) && (!is_terminal2) )
|
758 ks.madhusudan 1.20 {
|
759 venkat.puvvada 1.17 if( (k = opn2) > opn1 )
|
760 mike 1.16 {
761 opn2 = opn1;
762 opn1 = k;
763 }
|
764 ks.madhusudan 1.20 }
765 else if ((is_terminal1) && (!is_terminal2))
766 {
767 if ((k = opn2) > opn1)
|
768 mike 1.16 {
|
769 ks.madhusudan 1.20 opn2 = opn1;
770 opn1 = k;
771 is_terminal1 = false;
772 is_terminal2 = true;
|
773 mike 1.16 }
|
774 ks.madhusudan 1.20 }
775 PEG_METHOD_EXIT();
|
776 mike 1.16 }
777
|
778 schuur 1.1 PEGASUS_NAMESPACE_END
|
Return to
CMPI_Wql2Dnf.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI