compiler.compileMember(call.getArg(1));
return new AbstractMemberCalc(
call, new Calc[] {memberCalc, ancestorMemberCalc})
{
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
Member ancestorMember =
ancestorMemberCalc.evaluateMember(evaluator);
return cousin(
evaluator.getSchemaReader(),
member,
ancestorMember);
}
};
}
});
builder.define(HierarchyCurrentMemberFunDef.instance);
builder.define(NamedSetCurrentFunDef.instance);
builder.define(NamedSetCurrentOrdinalFunDef.instance);
// "<Member>.DataMember"
builder.define(
new FunDefBase(
"DataMember",
"Returns the system-generated data member that is associated with a nonleaf member of a dimension.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return member.getDataMember();
}
};
}
});
// "<Dimension>.DefaultMember". The function is implemented using an
// implicit cast to hierarchy, and we create a FunInfo for
// documentation & backwards compatibility.
builder.define(
new FunInfo(
"DefaultMember",
"Returns the default member of a dimension.",
"pmd"));
// "<Hierarchy>.DefaultMember"
builder.define(
new FunDefBase(
"DefaultMember",
"Returns the default member of a hierarchy.",
"pmh")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
return new AbstractMemberCalc(
call, new Calc[] {hierarchyCalc})
{
public Member evaluateMember(Evaluator evaluator) {
Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return evaluator.getSchemaReader()
.getHierarchyDefaultMember(hierarchy);
}
};
}
});
// "<Member>.FirstChild"
builder.define(
new FunDefBase(
"FirstChild",
"Returns the first child of a member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return firstChild(evaluator, member);
}
};
}
Member firstChild(Evaluator evaluator, Member member) {
List<Member> children = evaluator.getSchemaReader()
.getMemberChildren(member);
return (children.size() == 0)
? member.getHierarchy().getNullMember()
: children.get(0);
}
});
// <Member>.FirstSibling
builder.define(
new FunDefBase(
"FirstSibling",
"Returns the first child of the parent of a member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return firstSibling(member, evaluator);
}
};
}
Member firstSibling(Member member, Evaluator evaluator) {
Member parent = member.getParentMember();
List<Member> children;
final SchemaReader schemaReader = evaluator.getSchemaReader();
if (parent == null) {
if (member.isNull()) {
return member;
}
children = schemaReader.getHierarchyRootMembers(
member.getHierarchy());
} else {
children = schemaReader.getMemberChildren(parent);
}
return children.get(0);
}
});
builder.define(LeadLagFunDef.LagResolver);
// <Member>.LastChild
builder.define(
new FunDefBase(
"LastChild",
"Returns the last child of a member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return lastChild(evaluator, member);
}
};
}
Member lastChild(Evaluator evaluator, Member member) {
List<Member> children =
evaluator.getSchemaReader().getMemberChildren(member);
return (children.size() == 0)
? member.getHierarchy().getNullMember()
: children.get(children.size() - 1);
}
});
// <Member>.LastSibling
builder.define(
new FunDefBase(
"LastSibling",
"Returns the last child of the parent of a member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return firstSibling(member, evaluator);
}
};
}
Member firstSibling(Member member, Evaluator evaluator) {
Member parent = member.getParentMember();
List<Member> children;
final SchemaReader schemaReader = evaluator.getSchemaReader();
if (parent == null) {
if (member.isNull()) {
return member;
}
children = schemaReader.getHierarchyRootMembers(
member.getHierarchy());
} else {
children = schemaReader.getMemberChildren(parent);
}
return children.get(children.size() - 1);
}
});
builder.define(LeadLagFunDef.LeadResolver);
// Members(<String Expression>)
builder.define(
new FunDefBase(
"Members",
"Returns the member whose name is specified by a string expression.",
"fmS")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
throw new UnsupportedOperationException();
}
});
// <Member>.NextMember
builder.define(
new FunDefBase(
"NextMember",
"Returns the next member in the level that contains a specified member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return evaluator.getSchemaReader().getLeadMember(
member, 1);
}
};
}
});
builder.define(OpeningClosingPeriodFunDef.OpeningPeriodResolver);
builder.define(OpeningClosingPeriodFunDef.ClosingPeriodResolver);
builder.define(MemberOrderKeyFunDef.instance);
builder.define(ParallelPeriodFunDef.Resolver);
// <Member>.Parent
builder.define(
new FunDefBase(
"Parent",
"Returns the parent of a member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return memberParent(evaluator, member);
}
};
}
Member memberParent(Evaluator evaluator, Member member) {
Member parent =
evaluator.getSchemaReader().getMemberParent(member);
if (parent == null) {
parent = member.getHierarchy().getNullMember();
}
return parent;
}
});
// <Member>.PrevMember
builder.define(
new FunDefBase(
"PrevMember",
"Returns the previous member in the level that contains a specified member.",
"pmm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberCalc(call, new Calc[] {memberCalc}) {
public Member evaluateMember(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
return evaluator.getSchemaReader().getLeadMember(
member, -1);
}
};
}
});
builder.define(StrToMemberFunDef.INSTANCE);
builder.define(ValidMeasureFunDef.instance);
//
// NUMERIC FUNCTIONS
builder.define(AggregateFunDef.resolver);
// Obsolete??
builder.define(
new MultiResolver(
"$AggregateChildren",
"$AggregateChildren(<Hierarchy>)",
"Equivalent to 'Aggregate(<Hierarchy>.CurrentMember.Children); for internal use.",
new String[] {"Inh"}) {
protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
return new FunDefBase(dummyFunDef) {
public void unparse(Exp[] args, PrintWriter pw) {
pw.print(getName());
pw.print("(");
args[0].unparse(pw);
pw.print(")");
}
public Calc compileCall(
ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
final Calc valueCalc = new ValueCalc(call);
return new GenericCalc(call) {
public Object evaluate(Evaluator evaluator) {
Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return aggregateChildren(
evaluator, hierarchy, valueCalc);
}
public Calc[] getCalcs() {
return new Calc[] {hierarchyCalc, valueCalc};
}
};
}
Object aggregateChildren(
Evaluator evaluator,
Hierarchy hierarchy,
final Calc valueFunCall)
{
Member member =
evaluator.getParent().getContext(hierarchy);
List<Member> members = new ArrayList<Member>();
evaluator.getSchemaReader()
.getParentChildContributingChildren(
member.getDataMember(),
hierarchy,
members);
Aggregator aggregator =
(Aggregator) evaluator.getProperty(
Property.AGGREGATION_TYPE.name, null);
if (aggregator == null) {
throw FunUtil.newEvalException(
null,
"Could not find an aggregator in the current "
+ "evaluation context");
}
Aggregator rollup = aggregator.getRollup();
if (rollup == null) {
throw FunUtil.newEvalException(
null,
"Don't know how to rollup aggregator '"
+ aggregator + "'");
}
return rollup.aggregate(
evaluator.push(), members, valueFunCall);
}
};
}
});
builder.define(AvgFunDef.Resolver);
builder.define(CorrelationFunDef.Resolver);
builder.define(CountFunDef.Resolver);
// <Set>.Count
builder.define(
new FunDefBase(
"Count",
"Returns the number of tuples in a set including empty cells.",
"pnx")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final ListCalc listCalc =
compiler.compileList(call.getArg(0));
return new AbstractIntegerCalc(call, new Calc[] {listCalc}) {
public int evaluateInteger(Evaluator evaluator) {
List list = listCalc.evaluateList(evaluator);
return count(evaluator, list, true);
}
};
}
});
builder.define(CovarianceFunDef.CovarianceResolver);
builder.define(CovarianceFunDef.CovarianceNResolver);
builder.define(IifFunDef.STRING_INSTANCE);
builder.define(IifFunDef.NUMERIC_INSTANCE);
builder.define(IifFunDef.TUPLE_INSTANCE);
builder.define(IifFunDef.BOOLEAN_INSTANCE);
builder.define(IifFunDef.MEMBER_INSTANCE);
builder.define(IifFunDef.LEVEL_INSTANCE);
builder.define(IifFunDef.HIERARCHY_INSTANCE);
builder.define(IifFunDef.DIMENSION_INSTANCE);
builder.define(IifFunDef.SET_INSTANCE);
builder.define(LinReg.InterceptResolver);
builder.define(LinReg.PointResolver);
builder.define(LinReg.R2Resolver);
builder.define(LinReg.SlopeResolver);
builder.define(LinReg.VarianceResolver);
builder.define(MinMaxFunDef.MaxResolver);
builder.define(MinMaxFunDef.MinResolver);
builder.define(MedianFunDef.Resolver);
builder.define(PercentileFunDef.Resolver);
// <Level>.Ordinal
builder.define(
new FunDefBase(
"Ordinal",
"Returns the zero-based ordinal value associated with a level.",
"pnl")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final LevelCalc levelCalc =
compiler.compileLevel(call.getArg(0));
return new AbstractIntegerCalc(call, new Calc[] {levelCalc}) {
public int evaluateInteger(Evaluator evaluator) {
final Level level = levelCalc.evaluateLevel(evaluator);
return level.getDepth();
}
};
}
});
builder.define(RankFunDef.Resolver);
builder.define(CacheFunDef.Resolver);
builder.define(StdevFunDef.StdevResolver);
builder.define(StdevFunDef.StddevResolver);
builder.define(StdevPFunDef.StdevpResolver);
builder.define(StdevPFunDef.StddevpResolver);
builder.define(SumFunDef.Resolver);
// <Measure>.Value
builder.define(
new FunDefBase(
"Value",
"Returns the value of a measure.",
"pnm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new GenericCalc(call) {
public Object evaluate(Evaluator evaluator) {
Member member = memberCalc.evaluateMember(evaluator);
Member old = evaluator.setContext(member);
Object value = evaluator.evaluateCurrent();
evaluator.setContext(old);
return value;
}
public boolean dependsOn(Hierarchy hierarchy) {
if (super.dependsOn(hierarchy)) {
return true;
}
if (memberCalc.getType().usesHierarchy(
hierarchy, true))
{
return false;
}
return true;
}
public Calc[] getCalcs() {
return new Calc[] {memberCalc};
}
};
}
});
builder.define(VarFunDef.VarResolver);
builder.define(VarFunDef.VarianceResolver);
builder.define(VarPFunDef.VariancePResolver);
builder.define(VarPFunDef.VarPResolver);
//
// SET FUNCTIONS
builder.define(AddCalculatedMembersFunDef.resolver);
// Ascendants(<Member>)
builder.define(
new FunDefBase(
"Ascendants",
"Returns the set of the ascendants of a specified member.",
"fxm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberListCalc(call, new Calc[] {memberCalc})
{
public List<Member> evaluateMemberList(
Evaluator evaluator)
{
Member member = memberCalc.evaluateMember(evaluator);
return ascendants(evaluator.getSchemaReader(), member);
}
};
}
List<Member> ascendants(SchemaReader schemaReader, Member member) {
if (member.isNull()) {
return Collections.emptyList();
}
final List<Member> result = new ArrayList<Member>();
result.add(member);
schemaReader.getMemberAncestors(member, result);
return result;
}
});
builder.define(TopBottomCountFunDef.BottomCountResolver);
builder.define(TopBottomPercentSumFunDef.BottomPercentResolver);
builder.define(TopBottomPercentSumFunDef.BottomSumResolver);
builder.define(TopBottomCountFunDef.TopCountResolver);
builder.define(TopBottomPercentSumFunDef.TopPercentResolver);
builder.define(TopBottomPercentSumFunDef.TopSumResolver);
// <Member>.Children
builder.define(
new FunDefBase(
"Children",
"Returns the children of a member.",
"pxm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberListCalc(
call, new Calc[] {memberCalc}, false)
{
public List<Member> evaluateMemberList(
Evaluator evaluator)
{
// Return the list of children. The list is immutable,
// hence 'false' above.
Member member = memberCalc.evaluateMember(evaluator);
return getNonEmptyMemberChildren(evaluator, member);
}
};
}
});
builder.define(CrossJoinFunDef.Resolver);
builder.define(NonEmptyCrossJoinFunDef.Resolver);
builder.define(CrossJoinFunDef.StarResolver);
builder.define(DescendantsFunDef.Resolver);
builder.define(DescendantsFunDef.Resolver2);
builder.define(DistinctFunDef.instance);
builder.define(DrilldownLevelFunDef.Resolver);
builder.define(DrilldownLevelTopBottomFunDef.DrilldownLevelTopResolver);
builder.define(
DrilldownLevelTopBottomFunDef.DrilldownLevelBottomResolver);
builder.define(DrilldownMemberFunDef.Resolver);
if (false) builder.define(
new FunDefBase(
"DrilldownMemberBottom",
"DrilldownMemberBottom(<Set1>, <Set2>, <Count>[, [<Numeric Expression>][, RECURSIVE]])",
"Like DrilldownMember except that it includes only the bottom N children.",
"fx*")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
throw new UnsupportedOperationException();
}
});
if (false) builder.define(
new FunDefBase(
"DrilldownMemberTop",
"DrilldownMemberTop(<Set1>, <Set2>, <Count>[, [<Numeric Expression>][, RECURSIVE]])",
"Like DrilldownMember except that it includes only the top N children.",
"fx*")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
throw new UnsupportedOperationException();
}
});
if (false) builder.define(
new FunDefBase(
"DrillupLevel",
"DrillupLevel(<Set>[, <Level>])",
"Drills up the members of a set that are below a specified level.",
"fx*")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
throw new UnsupportedOperationException();
}
});
if (false) builder.define(
new FunDefBase(
"DrillupMember",
"DrillupMember(<Set1>, <Set2>)",
"Drills up the members in a set that are present in a second specified set.",
"fx*")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
throw new UnsupportedOperationException();
}
});
builder.define(ExceptFunDef.Resolver);
builder.define(ExistsFunDef.resolver);
builder.define(ExtractFunDef.Resolver);
builder.define(FilterFunDef.instance);
builder.define(GenerateFunDef.ListResolver);
builder.define(GenerateFunDef.StringResolver);
builder.define(HeadTailFunDef.HeadResolver);
builder.define(HierarchizeFunDef.Resolver);
builder.define(IntersectFunDef.resolver);
builder.define(LastPeriodsFunDef.Resolver);
// <Dimension>.Members is really just shorthand for <Hierarchy>.Members
builder.define(
new FunInfo(
"Members",
"Returns the set of members in a dimension.",
"pxd"));
// <Hierarchy>.Members
builder.define(
new FunDefBase(
"Members",
"Returns the set of members in a hierarchy.",
"pxh")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
return new AbstractMemberListCalc(
call, new Calc[] {hierarchyCalc})
{
public List<Member> evaluateMemberList(Evaluator evaluator)
{
Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return hierarchyMembers(hierarchy, evaluator, false);
}
};
}
});
// <Hierarchy>.AllMembers
builder.define(
new FunDefBase(
"AllMembers",
"Returns a set that contains all members, including calculated members, of the specified hierarchy.",
"pxh")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
return new AbstractMemberListCalc(
call, new Calc[] {hierarchyCalc})
{
public List<Member> evaluateMemberList(Evaluator evaluator)
{
Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return hierarchyMembers(hierarchy, evaluator, true);
}
};
}
});
// <Level>.Members
builder.define(LevelMembersFunDef.INSTANCE);
// <Level>.AllMembers
builder.define(
new FunDefBase(
"AllMembers",
"Returns a set that contains all members, including calculated members, of the specified level.",
"pxl")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final LevelCalc levelCalc =
compiler.compileLevel(call.getArg(0));
return new AbstractMemberListCalc(call, new Calc[] {levelCalc})
{
public List<Member> evaluateMemberList(Evaluator evaluator)
{
Level level = levelCalc.evaluateLevel(evaluator);
return levelMembers(level, evaluator, true);
}
};
}
});
builder.define(XtdFunDef.MtdResolver);
builder.define(OrderFunDef.Resolver);
builder.define(UnorderFunDef.Resolver);
builder.define(PeriodsToDateFunDef.Resolver);
builder.define(XtdFunDef.QtdResolver);
// StripCalculatedMembers(<Set>)
builder.define(
new FunDefBase(
"StripCalculatedMembers",
"Removes calculated members from a set.",
"fxx")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberListCalc listCalc =
(MemberListCalc) compiler.compileList(call.getArg(0));
return new AbstractMemberListCalc(call, new Calc[] {listCalc}) {
public List<Member> evaluateMemberList(Evaluator evaluator)
{
List<Member> list =
listCalc.evaluateMemberList(evaluator);
list = removeCalculatedMembers(list);
return list;
}
};
}
});
// <Member>.Siblings
builder.define(
new FunDefBase(
"Siblings",
"Returns the siblings of a specified member, including the member itself.",
"pxm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractMemberListCalc(call, new Calc[] {memberCalc})
{
public List<Member> evaluateMemberList(Evaluator evaluator)
{
final Member member =
memberCalc.evaluateMember(evaluator);
return memberSiblings(member, evaluator);
}
};
}
List<Member> memberSiblings(Member member, Evaluator evaluator) {
if (member.isNull()) {
// the null member has no siblings -- not even itself
return Collections.emptyList();
}
Member parent = member.getParentMember();
final SchemaReader schemaReader = evaluator.getSchemaReader();
if (parent == null) {
return schemaReader.getHierarchyRootMembers(
member.getHierarchy());
} else {
return schemaReader.getMemberChildren(parent);
}
}
});
builder.define(StrToSetFunDef.Resolver);
builder.define(SubsetFunDef.Resolver);
builder.define(HeadTailFunDef.TailResolver);
builder.define(ToggleDrillStateFunDef.Resolver);
builder.define(UnionFunDef.Resolver);
builder.define(VisualTotalsFunDef.Resolver);
builder.define(XtdFunDef.WtdResolver);
builder.define(XtdFunDef.YtdResolver);
builder.define(RangeFunDef.instance); // "<member> : <member>" operator
builder.define(SetFunDef.Resolver); // "{ <member> [,...] }" operator
builder.define(NativizeSetFunDef.Resolver);
//
// STRING FUNCTIONS
builder.define(FormatFunDef.Resolver);
// <Dimension>.Caption
builder.define(
new FunDefBase(
"Caption",
"Returns the caption of a dimension.",
"pSd")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final DimensionCalc dimensionCalc =
compiler.compileDimension(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {dimensionCalc})
{
public String evaluateString(Evaluator evaluator) {
final Dimension dimension =
dimensionCalc.evaluateDimension(evaluator);
return dimension.getCaption();
}
};
}
});
// <Hierarchy>.Caption
builder.define(
new FunDefBase(
"Caption",
"Returns the caption of a hierarchy.",
"pSh")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {hierarchyCalc})
{
public String evaluateString(Evaluator evaluator) {
final Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return hierarchy.getCaption();
}
};
}
});
// <Level>.Caption
builder.define(
new FunDefBase(
"Caption",
"Returns the caption of a level.",
"pSl")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final LevelCalc levelCalc =
compiler.compileLevel(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {levelCalc}) {
public String evaluateString(Evaluator evaluator) {
final Level level = levelCalc.evaluateLevel(evaluator);
return level.getCaption();
}
};
}
});
// <Member>.Caption
builder.define(
new FunDefBase(
"Caption",
"Returns the caption of a member.",
"pSm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {memberCalc}) {
public String evaluateString(Evaluator evaluator) {
final Member member =
memberCalc.evaluateMember(evaluator);
return member.getCaption();
}
};
}
});
// <Dimension>.Name
builder.define(
new FunDefBase(
"Name",
"Returns the name of a dimension.",
"pSd")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final DimensionCalc dimensionCalc =
compiler.compileDimension(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {dimensionCalc})
{
public String evaluateString(Evaluator evaluator) {
final Dimension dimension =
dimensionCalc.evaluateDimension(evaluator);
return dimension.getName();
}
};
}
});
// <Hierarchy>.Name
builder.define(
new FunDefBase(
"Name",
"Returns the name of a hierarchy.",
"pSh")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {hierarchyCalc})
{
public String evaluateString(Evaluator evaluator) {
final Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return hierarchy.getName();
}
};
}
});
// <Level>.Name
builder.define(
new FunDefBase(
"Name",
"Returns the name of a level.",
"pSl")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final LevelCalc levelCalc =
compiler.compileLevel(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {levelCalc}) {
public String evaluateString(Evaluator evaluator) {
final Level level = levelCalc.evaluateLevel(evaluator);
return level.getName();
}
};
}
});
// <Member>.Name
builder.define(
new FunDefBase(
"Name",
"Returns the name of a member.",
"pSm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {memberCalc}) {
public String evaluateString(Evaluator evaluator) {
final Member member =
memberCalc.evaluateMember(evaluator);
return member.getName();
}
};
}
});
builder.define(SetToStrFunDef.instance);
builder.define(TupleToStrFunDef.instance);
// <Dimension>.UniqueName
builder.define(
new FunDefBase(
"UniqueName",
"Returns the unique name of a dimension.",
"pSd")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final DimensionCalc dimensionCalc =
compiler.compileDimension(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {dimensionCalc})
{
public String evaluateString(Evaluator evaluator) {
final Dimension dimension =
dimensionCalc.evaluateDimension(evaluator);
return dimension.getUniqueName();
}
};
}
});
// <Hierarchy>.UniqueName
builder.define(
new FunDefBase(
"UniqueName",
"Returns the unique name of a hierarchy.",
"pSh")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final HierarchyCalc hierarchyCalc =
compiler.compileHierarchy(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {hierarchyCalc})
{
public String evaluateString(Evaluator evaluator) {
final Hierarchy hierarchy =
hierarchyCalc.evaluateHierarchy(evaluator);
return hierarchy.getUniqueName();
}
};
}
});
// <Level>.UniqueName
builder.define(
new FunDefBase(
"UniqueName",
"Returns the unique name of a level.",
"pSl")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final LevelCalc levelCalc =
compiler.compileLevel(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {levelCalc}) {
public String evaluateString(Evaluator evaluator) {
final Level level = levelCalc.evaluateLevel(evaluator);
return level.getUniqueName();
}
};
}
});
// <Member>.UniqueName
builder.define(
new FunDefBase(
"UniqueName",
"Returns the unique name of a member.",
"pSm")
{
public Calc compileCall(ResolvedFunCall call, ExpCompiler compiler)
{
final MemberCalc memberCalc =
compiler.compileMember(call.getArg(0));
return new AbstractStringCalc(call, new Calc[] {memberCalc}) {
public String evaluateString(Evaluator evaluator) {
final Member member =
memberCalc.evaluateMember(evaluator);
return member.getUniqueName();
}
};
}
});