mondrian.olap.Member Java Examples

protected Member yuckyInternalMondrianLookup( final Query query, final Hierarchy hierarchy, final String parameter ) {
  final Member memberById = (Member) Util.lookup( query, Util.parseIdentifier( parameter ) );
  if ( memberById != null ) {
    final Hierarchy memberHierarchy = memberById.getHierarchy();
    if ( hierarchy != memberHierarchy ) {
      if ( ObjectUtilities.equal( hierarchy, memberHierarchy ) == false ) {
        logger
          .warn( "Cannot match hierarchy of member found with the hierarchy specfied in the parameter: " // NON-NLS
            + "Unabe to guarantee that the correct member has been queried, returning null" ); // NON-NLS
        return null;
      }
    }
    return memberById;
  }
  return null;
}
 

public JRMondrianMember createMember(Member member)
{
	JRMondrianMember mondrianMember;
	if (member == null)
	{
		mondrianMember = null;
	}
	else
	{
		String key = member.getUniqueName();
		mondrianMember = members.get(key);
		if (mondrianMember == null)
		{
			mondrianMember = new JRMondrianMember(member, this);
			members.put(key, mondrianMember);
		}
	}
	return mondrianMember;
}
 

public List<Member> slice(final int column) {
    if (column < 0 || column >= arity) {
        throw new IllegalArgumentException();
    }
    return new AbstractList<Member>() {
        @Override
        public Member get(int index) {
            return ListTupleList.this.get(column, index);
        }

        @Override
        public int size() {
            return ListTupleList.this.size();
        }
    };
}
 

protected List<String> computeColumnNames( final Axis[] axes,
                                           final List<Member> columnToMemberMapper ) {
  ArrayList<String> columnNames = new ArrayList<String>();
  for ( final Member member : columnToMemberMapper ) {
    columnNames.add( member.getLevel().getUniqueName() );
  }
  if ( axes.length > 0 ) {
    // now create the column names for the column-axis
    final Axis axis = axes[ 0 ];
    final List<Position> positions = axis.getPositions();
    for ( int i = 0; i < positions.size(); i++ ) {
      final Position position = positions.get( i );
      columnNames.add( ResultSetProcessingLib.computeUniqueColumnName( position ) );
    }
  } else {
    columnNames.add( "Measure" );
  }
  return Collections.unmodifiableList( columnNames );
}
 

private Member getCandidateMembers( final int columnIndex,
                                    final int[] cellKey ) {

  final int axisIndex = columnToAxisPosition.get( columnIndex );
  final Axis[] axes = resultSet.getAxes();
  final Axis axis = axes[ axisIndex ];

  final List<Position> positionList = axis.getPositions();
  if ( positionList.isEmpty() ) {
    return null;
  }

  final int posIndex = cellKey[ axisIndex ];
  final Position position = positionList.get( posIndex );

  final Member memberByName = findMemberByName( position, columnIndex );
  if ( memberByName != null ) {
    return memberByName;
  }
  return findRootMember( position, columnIndex );
}
 

public static String getUniqueMemberName( Member member ) {
  String memberValue = Util.quoteMdxIdentifier( member.getName() );
  while ( member.getParentMember() != null ) {
    memberValue = Util.quoteMdxIdentifier( member.getParentMember().getName() ) + "." + memberValue;
    member = member.getParentMember();
  }
  final Hierarchy hierarchy = member.getHierarchy();
  final Dimension dimension = hierarchy.getDimension();
  if ( hierarchy.getName().equals( dimension.getName() ) ) {
    return Util.quoteMdxIdentifier( hierarchy.getName() ) + "." + memberValue;
  } else {
    return Util.quoteMdxIdentifier( dimension.getName() ) + "." + Util.quoteMdxIdentifier( hierarchy.getName() ) + "."
      +
      memberValue;
  }
}
 

private GenericObjectTable createColumnHeaders() {
  final Axis[] axes = this.resultSet.getAxes();
  if ( axes.length < 1 ) {
    return new GenericObjectTable();
  }
  final Axis axis = axes[ AXIS_COLUMN ];
  final List<Position> positions = axis.getPositions();
  final int colCount = positions.size();
  final GenericObjectTable result = new GenericObjectTable( 20, Math.max( 1, colCount ) );
  for ( int c = 0; c < colCount; c++ ) {
    final Position position = positions.get( c );
    Member member = null;
    final int rowCount = position.size();
    for ( int r = 0; r < rowCount; r++ ) {
      member = position.get( r );
      if ( member != null ) {
        result.setObject( r, c, member.getName() );
      }
    }

    if ( member != null ) {
      result.setObject( rowCount, c, member.getHierarchy().getName() );
    }
  }
  return result;
}
 

/**
 * @return
 */
private GenericObjectTable createRowHeaders() {
  final Axis[] axes = this.resultSet.getAxes();
  if ( axes.length < 2 ) {
    return new GenericObjectTable();
  }
  final Axis axis = axes[ AXIS_ROW ];
  final List<Position> positions = axis.getPositions();
  final int rowCount = positions.size();
  final GenericObjectTable result = new GenericObjectTable( Math.max( 1, rowCount ), 5 );

  for ( int r = 0; r < rowCount; r++ ) {
    final Position position = positions.get( r );
    Member member = null;
    final int colCount = position.size();
    for ( int c = 0; c < colCount; c++ ) {
      member = position.get( c );
      result.setObject( r, c, member.getName() );
    }
    if ( member != null ) {
      result.setObject( r, colCount, member.getHierarchy().getName() );
    }
  }
  return result;
}
 

private Member computeMeasureName( final Result resultSet ) {
  final List<Position> positionList = resultSet.getSlicerAxis().getPositions();
  for ( int i = 0; i < positionList.size(); i++ ) {
    final Position position = positionList.get( i );
    for ( int positionIndex = 0; positionIndex < position.size(); positionIndex++ ) {

      Member m = position.get( positionIndex );
      while ( m != null ) {
        if ( m.isMeasure() ) {
          return m;
        }
        m = m.getParentMember();
      }
    }
  }

  return null;
}
 

private Member getCandidateMembers( final int columnIndex,
                                    final int[] cellKey ) {

  final int axisIndex = columnToAxisPosition.get( columnIndex );
  final Axis[] axes = resultSet.getAxes();
  final Axis axis = axes[ axisIndex ];

  final List<Position> positionList = axis.getPositions();
  if ( positionList.isEmpty() ) {
    return null;
  }

  final int posIndex = cellKey[ axisIndex ];
  final Position position = positionList.get( posIndex );

  final Member memberByName = findMemberByName( position, columnIndex );
  if ( memberByName != null ) {
    return memberByName;
  }
  return findRootMember( position, columnIndex );
}
 

public static int computeMemberCountForAxis( final Axis axis,
                                             final boolean membersOnAxisSorted ) {
  final List<Position> positions = axis.getPositions();
  final MemberAddingStrategy strategy = membersOnAxisSorted ?
    new SortedMemberAddingStrategy( positions ) :
    new ResultSetOrderMemberAddingStrategy();

  for ( int positionsIndex = 0; positionsIndex < positions.size(); positionsIndex++ ) {
    final Position position = positions.get( positionsIndex );
    for ( int positionIndex = 0; positionIndex < position.size(); positionIndex++ ) {
      Member m = position.get( positionIndex );
      computeDeepColumnNames( m, strategy );
    }
  }

  return strategy.values().size();
}
 

public int compare( final Member o1, final Member o2 ) {
  Dimension d1 = o1.getLevel().getDimension();
  Dimension d2 = o2.getLevel().getDimension();
  int dimOrder = Integer.compare( getDimensionPositionOnAxis( d1 ), getDimensionPositionOnAxis( d2 ) );
  if ( dimOrder != 0 ) {
    return dimOrder;
  }

  Hierarchy h1 = o1.getHierarchy();
  Hierarchy h2 = o2.getHierarchy();
  int hierarchyOrder = h1.getName().compareTo( h2.getName() );
  if ( hierarchyOrder != 0 ) {
    return hierarchyOrder;
  }

  Level level1 = o1.getLevel();
  Level level2 = o2.getLevel();
  int levelOrder = Integer.compare( level1.getDepth(), level2.getDepth() );
  if ( levelOrder != 0 ) {
    return levelOrder;
  }
  return o1.getLevel().getUniqueName().compareTo( o2.getLevel().getUniqueName() );
}
 

private Member findRootMember( final List<Member> position, final int columnIndex ) {
  final Dimension dimension = columnToMemberMapping.get( columnIndex ).getDimension();
  for ( int i = 0; i < position.size(); i++ ) {
    final Member member = position.get( i );
    if ( dimension.equals( member.getDimension() ) ) {
      if ( member.getParentMember() == null ) {
        return member;
      }
    }
  }
  return null;
}
 

@Override
public List<Member> remove(int index) {
    assert mutable;
    for (int i = 0, n = index * arity; i < arity; i++) {
        list.remove(n);
    }
    return null; // breach of List contract
}
 

public TupleList cloneList(int capacity) {
    return new ListTupleList(
        arity,
        capacity < 0
            ? new ArrayList<Member>(list)
            : new ArrayList<Member>(capacity * arity));
}
 

@Override
public List<Member> remove(int index) {
    final Member member = list.remove(index);
    return member == null
        ? null
        : Collections.singletonList(member);
}
 

public TupleList cloneList(int capacity) {
    return new DelegatingTupleList(
        arity,
        capacity < 0
            ? new ArrayList<List<Member>>(list)
            : new ArrayList<List<Member>>(capacity));
}
 

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 );
      }
    }
  }
}
 

public JRMondrianTuple(Position position, JRMondrianFactory factory)
{
	members = new JRMondrianMember[position.size()];
	int idx = 0;
	for (Iterator<Member> it = position.iterator(); it.hasNext(); ++idx)
	{
		Member member = it.next();
		members[idx] = factory.createMember(member);
	}
}
 

public MemberComparator( final List<Position> positions ) {
  LinkedHashSet<Dimension> dimensionInOrder = new LinkedHashSet<Dimension>();
  for ( final Position position : positions ) {
    for ( final Member member : position ) {
      dimensionInOrder.add( member.getDimension() );
    }
  }

  dimensionOrder = new HashMap<Dimension, Integer>();
  for ( final Dimension dimension : dimensionInOrder ) {
    dimensionOrder.put( dimension, dimensionOrder.size() );
  }
}
 

/**
 * Column axis members can be nested (having multiple dimensions or multiple levels of the same dimension) and thus
 * the Member's unique name is not necessarily unique across the whole context (same year mentioned for different
 * product lines, for example). So we need to compute that name recursively.
 *
 * @param position The OLAP position, a list of members uniquely specifying a cell-position.
 * @return the computed name, usually jus a concat of all levels.
 */
public static String computeUniqueColumnName( final Position position ) {
  final StringBuilder positionName = new StringBuilder( 100 );
  for ( int j = 0; j < position.size(); j++ ) {
    if ( j != 0 ) {
      positionName.append( '/' );
    }
    final Member member = position.get( j );
    positionName.append( MondrianUtil.getUniqueMemberName( member ) );
  }
  return positionName.toString();
}
 

private Member findRootMember( final List<Member> position, final int columnIndex ) {
  final Dimension dimension = columnToMemberMapping.get( columnIndex ).getDimension();
  for ( int i = 0; i < position.size(); i++ ) {
    final Member member = position.get( i );
    if ( dimension.equals( member.getDimension() ) ) {
      if ( member.getParentMember() == null ) {
        return member;
      }
    }
  }
  return null;
}
 

private Member findMemberByName( final List<Member> position, final int columnIndex ) {
  final Dimension dimension = columnToMemberMapping.get( columnIndex ).getDimension();
  for ( int i = 0; i < position.size(); i++ ) {
    final Member member = position.get( i );
    if ( dimension.equals( member.getDimension() ) ) {
      Member match = searchContextMemberOfParents( member, columnIndex );
      if ( match != null ) {
        return match;
      }
    }
  }
  return null;
}
 

private Member searchContextMemberOfParents( final Member member, final int columnIndex ) {
  String columnName = getColumnName( columnIndex );

  Member candidate = member;
  while ( candidate != null ) {
    if ( candidate.getLevel().getUniqueName().equals( columnName ) ) {
      return candidate;
    }
    candidate = candidate.getParentMember();
  }
  return null;
}
 

/**
 * Computes a set of column names starting with the deepest parent up to the member actually found on the axis.
 *
 * @param m
 */
public static void computeDeepColumnNames( Member m,
                                           final MemberAddingStrategy memberToNameMapping ) {
  final FastStack<Member> memberStack = new FastStack<Member>();
  while ( m != null ) {
    memberStack.push( m );
    m = m.getParentMember();
  }

  while ( memberStack.isEmpty() == false ) {
    Member mx = memberStack.pop();
    memberToNameMapping.add( mx );
  }
}
 

public MDXMetaDataMemberAttributes( final DataAttributes backend,
                                    final Member cell ) {
  if ( cell == null ) {
    throw new NullPointerException();
  }
  if ( backend == null ) {
    throw new NullPointerException();
  }
  this.cell = cell;
  this.backend = backend;
}
 

public static ArrayList<Member> computeColumnToMemberMapping( final Axis[] axes,
                                                              final int[] axesMembers,
                                                              final int startAxis,
                                                              final boolean membersOnAxisSorted ) {
  final ArrayList<Member> columnToMemberMapper = new ArrayList<Member>();
  for ( int axesIndex = axes.length - 1; axesIndex >= startAxis; axesIndex -= 1 ) {
    final Axis axis = axes[ axesIndex ];
    final List<Position> positions = axis.getPositions();

    final MemberAddingStrategy strategy = membersOnAxisSorted ?
      new SortedMemberAddingStrategy( positions ) :
      new ResultSetOrderMemberAddingStrategy();

    for ( int positionsIndex = 0; positionsIndex < positions.size(); positionsIndex++ ) {
      final Position position = positions.get( positionsIndex );
      for ( int positionIndex = 0; positionIndex < position.size(); positionIndex++ ) {
        Member m = position.get( positionIndex );
        computeDeepColumnNames( m, strategy );
      }
    }

    Collection<Member> columnNamesSet = strategy.values();
    if ( columnNamesSet.size() != axesMembers[ axesIndex ] ) {
      logger.error( "ERROR: Number of names is not equal the pre-counted number." );
    }

    columnToMemberMapper.addAll( columnNamesSet );
  }
  return columnToMemberMapper;
}
 

private List<String> computeColumnNames( final List<Member> columnToMemberMapper ) {
  ArrayList<String> columnNames = new ArrayList<String>();
  for ( final Member member : columnToMemberMapper ) {
    columnNames.add( member.getLevel().getUniqueName() );
  }

  final Member measureName = computeMeasureName( resultSet );
  if ( measureName != null ) {
    columnNames.add( measureName.getUniqueName() );
  } else {
    columnNames.add( "Measure" );
  }
  return columnNames;
}
 

private Member searchContextMemberOfParents( final Member member, final int columnIndex ) {
  String columnName = getColumnName( columnIndex );

  Member candidate = member;
  while ( candidate != null ) {
    if ( candidate.getLevel().getUniqueName().equals( columnName ) ) {
      return candidate;
    }
    candidate = candidate.getParentMember();
  }
  return null;
}
 

private Member findMemberByName( final List<Member> position, final int columnIndex ) {
  final Dimension dimension = columnToMemberMapping.get( columnIndex ).getDimension();
  for ( int i = 0; i < position.size(); i++ ) {
    final Member member = position.get( i );
    if ( dimension.equals( member.getDimension() ) ) {
      Member match = searchContextMemberOfParents( member, columnIndex );
      if ( match != null ) {
        return match;
      }
    }
  }
  return null;
}