How to use

getAxes

method

in

mondrian.olap.Result

private static void outputFlattenedRecurse( Result result, List<List<Object>> rows, List<Object> rowValues,
 int[] coords, int axisOrdinal ) {
 final Axis[] axes = result.getAxes();
 if ( axisOrdinal == axes.length ) {
  final Cell cell = result.getCell( coords );
  // Output the raw (unformatted) value of the cell.
  // NOTE: We could output other properties of the cell here, such as its
  // formatted value, too.
  rowValues.add( cell.getValue() );
  // Add a copy of the completed row to the list of rows.
  rows.add( new ArrayList<>( rowValues ) );
 } else {
  final Axis axis = axes[axisOrdinal];
  int k = -1;
  int saveLength = rowValues.size();
  for ( Position position : axis.getPositions() ) {
   coords[axisOrdinal] = ++k;
   for ( Member member : position ) {
    rowValues.add( member.getUniqueName() );
   }
   outputFlattenedRecurse( result, rows, rowValues, coords, axisOrdinal + 1 );
   while ( rowValues.size() > saveLength ) {
    rowValues.remove( rowValues.size() - 1 );
   }
  }
 }
}

final Axis[] axes = result.getAxes();
rows = new ArrayList<>();
headings = new ArrayList<>();

final Axis[] axes = result.getAxes();
if ( axes.length != 2 ) {
 throw new KettleDatabaseException( BaseMessages.getString( PKG, "MondrianInputErrorOnlyTabular" ) );

private String getBoundsAsString() {
  StringBuilder buf = new StringBuilder();
  Axis[] axes = result.getAxes();
  for (int i = 0; i < axes.length; i++) {
    if (i > 0) {
      buf.append(", ");
    }
    buf.append(axes[i].getPositions().size());
  }
  return buf.toString();
}

  void buildCornerElement(Element row) {
    Element corner = elem("corner", row);
    corner.setAttribute(
      "rowspan",
      Integer.toString(
        result.getAxes()[0].getPositions().get(0).size()));
    corner.setAttribute(
      "colspan",
      Integer.toString(
        result.getAxes()[1].getPositions().get(0).size()));
  }
}

private int[] ordinalToCoordinateArray(int ordinal) {
  Axis[] axes = result.getAxes();
  final int[] pos = new int[axes.length];
  int modulo = 1;
  for (int i = 0; i < axes.length; i++) {
    int prevModulo = modulo;
    modulo *= axes[i].getPositions().size();
    pos[i] = (ordinal % modulo) / prevModulo;
  }
  if (ordinal < 0 || ordinal >= modulo) {
    throw new IndexOutOfBoundsException(
      "Cell ordinal " + ordinal
      + ") lies outside CellSet bounds ("
      + getBoundsAsString() + ")");
  }
  return pos;
}

private void buildCells(Element row, int[] cellIndex, boolean even) {
  int columns = result.getAxes()[0].getPositions().size();
  for (int i = 0; i < columns; i++) {
    cellIndex[0] = i;
    Cell cell = result.getCell(cellIndex);
    buildCell(cell, row, even);
  }
}

html.append(Util.nl);
List<Position> columns = result.getAxes()[0].getPositions();
List<Position> rows = null;
if (result.getAxes().length == 2) {
  rows = result.getAxes()[1].getPositions();
if (result.getAxes().length == 2) {
  rowWidth = result.getAxes()[1].getPositions().get(0).size();
  if (j == 0 && result.getAxes().length > 1) {
if (result.getAxes().length > 1) {
  for (int i = 0; i < rows.size(); i++) {
    html.append("<tr>");

private Element build() {
  dimCount = result.getAxes().length;
  Element mdxtable = factory.createElement("mdxtable");
  Element query = elem("query", mdxtable);
  cdata(Util.unparse(result.getQuery()), query);
  Element head = elem("head", mdxtable);
  Element body = elem("body", mdxtable);
  switch (dimCount) {
  case 0:
    buildRows0Dim(body);
    break;
  case 1:
    buildColumns(head, result.getAxes()[0]);
    buildRows1Dim(body);
    break;
  case 2:
    buildColumns(head, result.getAxes()[0]);
    buildRows2Dim(body, result.getAxes()[1]);
    break;
  default:
    throw new IllegalArgumentException(
      "DomBuilder requires 0, 1 or 2 dimensional result");
  }
  Element slicers = elem("slicers", mdxtable);
  buildSlicer(slicers);
  return mdxtable;
}

super(execution, result.getAxes().clone());
int axisCount = underlying.getAxes().length;
this.pos = new int[axisCount];
this.slicerAxis = underlying.getSlicerAxis();
TupleList tupleList =
  ((RolapAxis) underlying.getAxes()[axis]).getTupleList();

mondrian.olap.Axis[] axes = result.getAxes();
QueryAxis[] queryAxes = result.getQuery().getAxes();
assert axes.length == queryAxes.length;

public JRMondrianResult(Result result)
{
  this.result = result;
  JRMondrianFactory factory = new JRMondrianFactory();
  Query query = result.getQuery();
  Axis[] resultAxes = result.getAxes();
  axes = new JRMondrianAxis[resultAxes.length];
  for (int i = 0; i < resultAxes.length; i++)
  {
    AxisOrdinal ordinal = AxisOrdinal.StandardAxisOrdinal.forLogicalOrdinal(i);
    axes[i] = new JRMondrianAxis(resultAxes[i], query.getMdxHierarchiesOnAxis(ordinal), factory);
  }
}