コード例 #1
0
  /**
   * Returns the grand total measure values.
   *
   * @return the grand total measure values
   */
  public MeasureValue[] getGrandTotals() {
    BucketMap map = bucketValueMap;

    for (int i = 0; map != null && i < allBuckets.length - 1; ++i) {
      map = (BucketMap) map.getTotalEntry().getValue();
    }

    return map == null ? null : (MeasureValue[]) map.getTotalEntry().getValue();
  }
コード例 #2
0
  protected MeasureValue[][][] retrieveTotals(List vals, List bucketMaps) {
    MeasureValue[][][] totals = new MeasureValue[rowBucketCount + 1][colBucketCount + 1][];

    for (int row = rowRetrTotalMax; row >= rowRetrTotalMin; --row) {
      if (!rowRetrTotals[row]) {
        continue;
      }

      BucketMap rowMap = (BucketMap) bucketMaps.get(row);
      for (int i = row; rowMap != null && i < rowBucketCount; ++i) {
        Entry totalEntry = rowMap.getTotalEntry();
        rowMap = totalEntry == null ? null : (BucketMap) totalEntry.getValue();
      }

      for (int col = 0; col <= rowRetrColMax[row]; ++col) {
        BucketMap colMap = rowMap;

        if (col < colBucketCount - 1) {
          if (row == rowBucketCount) {
            rowMap = (BucketMap) bucketMaps.get(rowBucketCount + col + 1);
          } else if (rowMap != null) {
            rowMap = (BucketMap) rowMap.get((Bucket) vals.get(rowBucketCount + col));
          }
        }

        if (!retrieveTotal[row][col]) {
          continue;
        }

        for (int i = col + 1; colMap != null && i < colBucketCount; ++i) {
          colMap = (BucketMap) colMap.getTotalEntry().getValue();
        }

        if (colMap != null) {
          if (col == colBucketCount) {
            MeasureValue[] measureValues =
                (MeasureValue[]) colMap.get((Bucket) vals.get(rowBucketCount + colBucketCount - 1));
            totals[row][col] = getUserMeasureValues(measureValues);
          } else {
            Map.Entry totalEntry = colMap.getTotalEntry();
            if (totalEntry != null) {
              MeasureValue[] totalValues = (MeasureValue[]) totalEntry.getValue();
              totals[row][col] = getUserMeasureValues(totalValues);
            }
          }
        }

        if (totals[row][col] == null) {
          totals[row][col] = zeroUserMeasureValues;
        }
      }
    }

    return totals;
  }
コード例 #3
0
  protected void createCrosstab() throws JRException {
    CollectedList[] collectedHeaders = new CollectedList[BucketingService.DIMENSIONS];
    collectedHeaders[DIMENSION_ROW] = createHeadersList(DIMENSION_ROW, bucketValueMap, 0, false);

    BucketListMap collectedCols;
    if (allBuckets[0].computeTotal()) {
      BucketMap map = bucketValueMap;
      for (int i = 0; i < rowBucketCount; ++i) {
        map = (BucketMap) map.getTotalEntry().getValue();
      }
      collectedCols = (BucketListMap) map;
    } else {
      collectedCols = createCollectBucketMap(rowBucketCount);
      collectCols(collectedCols, bucketValueMap);
    }
    collectedHeaders[DIMENSION_COLUMN] =
        createHeadersList(DIMENSION_COLUMN, collectedCols, 0, false);

    int rowBuckets = collectedHeaders[BucketingService.DIMENSION_ROW].span;
    int colBuckets = collectedHeaders[BucketingService.DIMENSION_COLUMN].span;

    int bucketMeasureCount = rowBuckets * colBuckets * origMeasureCount;
    checkBucketMeasureCount(bucketMeasureCount);

    colHeaders = createHeaders(BucketingService.DIMENSION_COLUMN, collectedHeaders);
    rowHeaders = createHeaders(BucketingService.DIMENSION_ROW, collectedHeaders);

    cells = new CrosstabCell[rowBuckets][colBuckets];
    fillCells(
        collectedHeaders, bucketValueMap, 0, new int[] {0, 0}, new ArrayList(), new ArrayList());
  }
コード例 #4
0
  protected void collectCols(BucketListMap collectedCols, BucketMap bucketMap) throws JRException {
    if (allBuckets[bucketMap.level].computeTotal()) {
      BucketMap map = bucketMap;
      for (int i = bucketMap.level; i < rowBucketCount; ++i) {
        map = (BucketMap) map.getTotalEntry().getValue();
      }
      collectedCols.collectVals(map, false);

      return;
    }

    for (Iterator it = bucketMap.entryIterator(); it.hasNext(); ) {
      Map.Entry entry = (Map.Entry) it.next();
      BucketMap nextMap = (BucketMap) entry.getValue();
      if (bucketMap.level == rowBucketCount - 1) {
        collectedCols.collectVals(nextMap, false);
      } else {
        collectCols(collectedCols, nextMap);
      }
    }
  }
コード例 #5
0
  protected void fillCells(
      CollectedList[] collectedHeaders,
      BucketMap bucketMap,
      int level,
      int[] pos,
      List vals,
      List bucketMaps) {
    bucketMaps.add(bucketMap);

    byte dimension = level < rowBucketCount ? DIMENSION_ROW : DIMENSION_COLUMN;
    boolean last = level == allBuckets.length - 1;

    CollectedList[] nextCollected = null;
    if (!last) {
      nextCollected = new CollectedList[DIMENSIONS];
      for (int d = 0; d < DIMENSIONS; ++d) {
        if (d != dimension) {
          nextCollected[d] = collectedHeaders[d];
        }
      }
    }

    boolean incrementRow = level == buckets[BucketingService.DIMENSION_ROW].length - 1;

    CollectedList collectedList = collectedHeaders[dimension];

    Iterator bucketIt = bucketMap == null ? null : bucketMap.entryIterator();
    Map.Entry bucketItEntry =
        bucketIt != null && bucketIt.hasNext() ? (Map.Entry) bucketIt.next() : null;
    for (Iterator it = collectedList.iterator(); it.hasNext(); ) {
      CollectedList list = (CollectedList) it.next();

      Map.Entry bucketEntry = null;
      if (list.key.isTotal()) {
        if (bucketMap != null) {
          bucketEntry = bucketMap.getTotalEntry();
        }
      } else {
        if (bucketItEntry != null && bucketItEntry.getKey().equals(list.key)) {
          bucketEntry = bucketItEntry;
          bucketItEntry = bucketIt.hasNext() ? (Map.Entry) bucketIt.next() : null;
        }
      }

      vals.add(list.key);
      if (last) {
        fillCell(pos, vals, bucketMaps, bucketEntry);
      } else {
        nextCollected[dimension] = list;
        BucketMap nextMap = bucketEntry == null ? null : (BucketMap) bucketEntry.getValue();

        fillCells(nextCollected, nextMap, level + 1, pos, vals, bucketMaps);
      }
      vals.remove(vals.size() - 1);

      if (incrementRow) {
        ++pos[0];
        pos[1] = 0;
      }
    }

    bucketMaps.remove(bucketMaps.size() - 1);
  }