KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > mondrian > olap > fun > DrilldownMemberFunDef


1 /*
2 // $Id: //open/mondrian/src/main/mondrian/olap/fun/DrilldownMemberFunDef.java#10 $
3 // This software is subject to the terms of the Common Public License
4 // Agreement, available at the following URL:
5 // http://www.opensource.org/licenses/cpl.html.
6 // Copyright (C) 2004-2006 Julian Hyde
7 // All Rights Reserved.
8 // You must accept the terms of that agreement to use this software.
9 */
10 package mondrian.olap.fun;
11
12 import mondrian.olap.*;
13 import mondrian.calc.*;
14 import mondrian.calc.impl.AbstractListCalc;
15 import mondrian.mdx.ResolvedFunCall;
16
17 import java.util.HashSet JavaDoc;
18 import java.util.Set JavaDoc;
19 import java.util.List JavaDoc;
20 import java.util.ArrayList JavaDoc;
21
22 /**
23  * Definition of the <code>DrilldownMember</code> MDX function.
24  *
25  * @author Grzegorz Lojek
26  * @since 6 December, 2004
27  * @version $Id: //open/mondrian/src/main/mondrian/olap/fun/DrilldownMemberFunDef.java#10 $
28  */
29 class DrilldownMemberFunDef extends FunDefBase {
30     static final String JavaDoc[] reservedWords = new String JavaDoc[] {"RECURSIVE"};
31     static final ReflectiveMultiResolver Resolver = new ReflectiveMultiResolver(
32             "DrilldownMember",
33             "DrilldownMember(<Set1>, <Set2>[, RECURSIVE])",
34             "Drills down the members in a set that are present in a second specified set.",
35             new String JavaDoc[]{"fxxx", "fxxxy"},
36             DrilldownMemberFunDef.class,
37             reservedWords);
38
39     public DrilldownMemberFunDef(FunDef funDef) {
40         super(funDef);
41     }
42
43     public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler) {
44         final ListCalc listCalc1 = compiler.compileList(call.getArg(0));
45         final ListCalc listCalc2 = compiler.compileList(call.getArg(1));
46         final String JavaDoc literalArg = getLiteralArg(call, 2, "", reservedWords);
47         final boolean recursive = literalArg.equals("RECURSIVE");
48
49         return new AbstractListCalc(call, new Calc[] {listCalc1, listCalc2}) {
50             public List JavaDoc evaluateList(Evaluator evaluator) {
51                 final List JavaDoc list1 = listCalc1.evaluateList(evaluator);
52                 final List JavaDoc list2 = listCalc2.evaluateList(evaluator);
53                 return drilldownMember(list1, list2, evaluator);
54             }
55
56             /**
57              * Drills down an element.
58              *
59              * Algorithm: If object is present in a_hsSet1 then adds to result children
60              * of the object. If flag a_bRecursive is set then this method is called
61              * recursively for the children.
62              *
63              * @param element Element of a set, can be either {@link Member} or
64              * {@link Member}[]
65              *
66              *
67              */
68             protected void drillDownObj(
69                     Evaluator evaluator,
70                     Object JavaDoc element,
71                     Set JavaDoc memberSet,
72                     List JavaDoc resultList) {
73                 if (null == element) {
74                     return;
75                 }
76
77                 Member m = null;
78                 int k = -1;
79                 if (element instanceof Member) {
80                     if (!memberSet.contains(element)) {
81                         return;
82                     }
83                     m = (Member) element;
84                 } else {
85                     Util.assertTrue(element instanceof Member[]);
86                     Member[] members = (Member[]) element;
87                     for (int j = 0; j < members.length; j++) {
88                         Member member = members[j];
89                         if (memberSet.contains(member)) {
90                             k = j;
91                             m = member;
92                             break;
93                         }
94                     }
95                     if (k == -1) {
96                         return;
97                     }
98                 }
99
100                 Member[] children = evaluator.getSchemaReader().getMemberChildren(m);
101                 for (int j = 0; j < children.length; j++) {
102                     Object JavaDoc objNew;
103                     if (k < 0) {
104                         objNew = children[j];
105                     } else {
106                         Member[] members = (Member[]) ((Member[]) element).clone();
107                         members[k] = children[j];
108                         objNew = members;
109                     }
110
111                     resultList.add(objNew);
112                     if (recursive) {
113                         drillDownObj(evaluator, objNew, memberSet, resultList);
114                     }
115                 }
116             }
117
118             private List JavaDoc drilldownMember(List JavaDoc v0, List JavaDoc v1, Evaluator evaluator) {
119                 if (null == v0 ||
120                     v0.isEmpty() ||
121                     null == v1 ||
122                     v1.isEmpty()) {
123                     return v0;
124                 }
125
126                 Set JavaDoc set1 = new HashSet JavaDoc();
127                 set1.addAll(v1);
128
129                 List JavaDoc result = new ArrayList JavaDoc();
130                 int i = 0, n = v0.size();
131                 while (i < n) {
132                     Object JavaDoc o = v0.get(i++);
133                     result.add(o);
134                     drillDownObj(evaluator, o, set1, result);
135                 }
136                 return result;
137             }
138         };
139     }
140 }
141
142 // End DrilldownMemberFunDef.java
143
Popular Tags