public List<RolapMember> getMembersInLevel(
     RolapLevel level, int startOrdinal, int endOrdinal, TupleConstraint constraint) {
   if (hierarchyAccess != null) {
     final int depth = level.getDepth();
     if (depth < hierarchyAccess.getTopLevelDepth()) {
       return Collections.emptyList();
     }
     if (depth > hierarchyAccess.getBottomLevelDepth()) {
       return Collections.emptyList();
     }
   }
   final List<RolapMember> membersInLevel =
       memberReader.getMembersInLevel(level, startOrdinal, endOrdinal, constraint);
   List<RolapMember> filteredMembers = new ArrayList<RolapMember>();
   filterMembers(membersInLevel, filteredMembers);
   return filteredMembers;
 }
 public RolapMember getDefaultMember() {
   RolapMember defaultMember = (RolapMember) getHierarchy().getDefaultMember();
   if (defaultMember != null) {
     Access i = hierarchyAccess.getAccess(defaultMember);
     if (i != Access.NONE) {
       return defaultMember;
     }
   }
   return getRootMembers().get(0);
 }
 private boolean canSee(final RolapMember member) {
   if (ragged && member.isHidden()) {
     return false;
   }
   if (hierarchyAccess != null) {
     final Access access = hierarchyAccess.getAccess(member);
     return access != Access.NONE;
   }
   return true;
 }
 public RolapMember getMemberParent(RolapMember member) {
   RolapMember parentMember = member.getParentMember();
   // Skip over hidden parents.
   while (parentMember != null && parentMember.isHidden()) {
     parentMember = parentMember.getParentMember();
   }
   // Skip over non-accessible parents.
   if (parentMember != null) {
     if (hierarchyAccess.getAccess(parentMember) == Access.NONE) {
       return null;
     }
   }
   return parentMember;
 }
 public List<RolapMember> getRootMembers() {
   int topLevelDepth = hierarchyAccess.getTopLevelDepth();
   if (topLevelDepth > 0) {
     RolapLevel topLevel = (RolapLevel) getHierarchy().getLevels()[topLevelDepth];
     final List<RolapMember> memberList = getMembersInLevel(topLevel, 0, Integer.MAX_VALUE);
     if (memberList.isEmpty()) {
       throw MondrianResource.instance()
           .HierarchyHasNoAccessibleMembers
           .ex(getHierarchy().getUniqueName());
     }
     return memberList;
   }
   return super.getRootMembers();
 }
 private void processMemberChildren(
     List<RolapMember> fullChildren,
     List<RolapMember> children,
     MemberChildrenConstraint constraint) {
   // todo: optimize if parentMember is beyond last level
   List<RolapMember> grandChildren = null;
   for (int i = 0; i < fullChildren.size(); i++) {
     RolapMember member = fullChildren.get(i);
     // If a child is hidden (due to raggedness) include its children.
     // This must be done before applying access-control.
     if (ragged) {
       if (member.isHidden()) {
         // Replace this member with all of its children.
         // They might be hidden too, but we'll get to them in due
         // course. They also might be access-controlled; that's why
         // we deal with raggedness before we apply access-control.
         fullChildren.remove(i);
         if (grandChildren == null) {
           grandChildren = new ArrayList<RolapMember>();
         } else {
           grandChildren.clear();
         }
         memberReader.getMemberChildren(member, grandChildren, constraint);
         fullChildren.addAll(i, grandChildren);
         // Step back to before the first child we just inserted,
         // and go through the loop again.
         --i;
         continue;
       }
     }
     // Filter out children which are invisible because of
     // access-control.
     final Access access;
     if (hierarchyAccess != null) {
       access = hierarchyAccess.getAccess(member);
     } else {
       access = Access.ALL;
     }
     switch (access) {
       case NONE:
         break;
       default:
         children.add(member);
         break;
     }
   }
 }