Ejemplo n.º 1
0
 /**
  * Returns the number of matrix columns required by this axis. The sum of the width of the
  * hierarchies on this axis.
  *
  * @return Width of axis
  */
 public int getWidth() {
   int width = 0;
   for (final AxisOrdinalInfo info : ordinalInfos) {
     width += info.getWidth();
   }
   return width;
 }
Ejemplo n.º 2
0
  /**
   * Populates cells in the matrix corresponding to a particular axis.
   *
   * @param matrix Matrix to populate
   * @param axis Axis
   * @param axisInfo Description of axis
   * @param isColumns True if columns, false if rows
   * @param offset Ordinal of first cell to populate in matrix
   */
  private void populateAxis(
      final Matrix matrix,
      final CellSetAxis axis,
      final AxisInfo axisInfo,
      final boolean isColumns,
      final int offset) {

    if (axis == null) return;
    final Member[] prevMembers = new Member[axisInfo.getWidth()];
    final MemberCell[] prevMemberInfo = new MemberCell[axisInfo.getWidth()];
    final Member[] members = new Member[axisInfo.getWidth()];

    for (int i = 0; i < axis.getPositions().size(); i++) {
      final int x = offset + i;
      final Position position = axis.getPositions().get(i);
      int yOffset = 0;
      final List<Member> memberList = position.getMembers();
      final Map<Dimension, List<Integer>> lvls = new HashMap<Dimension, List<Integer>>();
      for (int j = 0; j < memberList.size(); j++) {
        Member member = memberList.get(j);
        final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(j);
        List<Integer> depths = ordinalInfo.depths;
        Collections.sort(depths);
        lvls.put(member.getDimension(), depths);
        if (ordinalInfo.getDepths().size() > 0
            && member.getDepth() < ordinalInfo.getDepths().get(0)) break;
        final int y = yOffset + ordinalInfo.depths.indexOf(member.getDepth());
        members[y] = member;
        yOffset += ordinalInfo.getWidth();
      }

      boolean expanded = false;
      boolean same = true;
      for (int y = 0; y < members.length; y++) {
        final MemberCell memberInfo = new MemberCell();
        final Member member = members[y];
        expanded = false;
        int index = memberList.indexOf(member);
        if (index >= 0) {
          final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(index);
          int depth_i = ordinalInfo.getDepths().indexOf(member.getDepth());
          if (depth_i > 0) {
            expanded = true;
          }
        }
        memberInfo.setExpanded(expanded);
        same = same && i > 0 && Olap4jUtil.equal(prevMembers[y], member);

        if (member != null) {
          if (lvls != null && lvls.get(member.getDimension()) != null) {
            memberInfo.setProperty(
                "levelindex",
                "" + lvls.get(member.getDimension()).indexOf(member.getLevel().getDepth()));
          }
          if (x - 1 == offset) memberInfo.setLastRow(true);

          matrix.setOffset(offset);
          memberInfo.setRawValue(member.getCaption());
          memberInfo.setFormattedValue(member.getCaption()); // First try to get a formatted value
          memberInfo.setParentDimension(member.getDimension().getName());
          memberInfo.setHierarchy(member.getHierarchy().getName());
          memberInfo.setLevel(member.getLevel().getUniqueName());
          memberInfo.setUniquename(member.getUniqueName());
          //					try {
          //						memberInfo.setChildMemberCount(member.getChildMemberCount());
          //					} catch (OlapException e) {
          //						e.printStackTrace();
          //						throw new RuntimeException(e);
          //					}
          //					NamedList<Property> values = member.getLevel().getProperties();
          //					for(int j=0; j<values.size();j++){
          //						String val;
          //						try {
          //							val = member.getPropertyFormattedValue(values.get(j));
          //						} catch (OlapException e) {
          //							e.printStackTrace();
          //							throw new RuntimeException(e);
          //						}
          //						memberInfo.setProperty(values.get(j).getCaption(), val);
          //					}

          if (y > 0) {
            for (int previ = y - 1; previ >= 0; previ--) {
              if (prevMembers[previ] != null) {
                memberInfo.setRightOf(prevMemberInfo[previ]);
                memberInfo.setRightOfDimension(prevMembers[previ].getDimension().getName());
                previ = -1;
              }
            }
          }

          if (member.getParentMember() != null)
            memberInfo.setParentMember(member.getParentMember().getUniqueName());

        } else {
          memberInfo.setRawValue(null);
          memberInfo.setFormattedValue(null);
          memberInfo.setParentDimension(null);
        }

        if (isColumns) {
          memberInfo.setRight(false);
          memberInfo.setSameAsPrev(same);
          if (member != null) memberInfo.setParentDimension(member.getDimension().getName());
          matrix.set(x, y, memberInfo);
        } else {
          memberInfo.setRight(false);
          memberInfo.setSameAsPrev(false);
          matrix.set(y, x, memberInfo);
        }
        int x_parent = isColumns ? x : y - 1;
        int y_parent = isColumns ? y - 1 : x;
        if (index >= 0) {
          final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(index);
          int depth_i = ordinalInfo.getDepths().indexOf(member.getDepth());
          while (depth_i > 0) {
            depth_i--;
            Level l = ordinalInfo.getLevel(ordinalInfo.getDepths().get(depth_i));
            Member parent = member.getParentMember();
            while (l != null
                && parent != null
                && !parent.getLevel().getUniqueName().equals(l.getUniqueName())) {
              parent = parent.getParentMember();
            }
            final MemberCell pInfo = new MemberCell();
            pInfo.setRawValue(parent.getCaption());
            pInfo.setFormattedValue(parent.getCaption()); // First try to get a formatted value
            pInfo.setParentDimension(parent.getDimension().getName());
            pInfo.setHierarchy(parent.getHierarchy().getName());
            pInfo.setLevel(parent.getLevel().getUniqueName());
            pInfo.setUniquename(parent.getUniqueName());
            matrix.set(x_parent, y_parent, pInfo);
            if (isColumns) {
              y_parent--;
            } else {
              x_parent--;
            }
          }
        }
        prevMembers[y] = member;
        prevMemberInfo[y] = memberInfo;
        members[y] = null;
      }
    }
  }