levelledexpressionlist.java

来自「swing编写的库存管理程序。毕业设计类」· Java 代码 · 共 1,180 行 · 第 1/2 页

   *
   * @param event  the event.
   */
  public void itemsFinished(final ReportEvent event)
  {
    // clearError(); done in the prepare event ...

    for (int i = 0; i < levels.length; i++)
    {
      final int level = levels[i];
      if (level < getLevel())
      {
        break;
      }
      final Object[] itLevel = levelData[i];
      for (int l = 0; l < itLevel.length; l++)
      {
        final Expression e = (Expression) itLevel[l];
        if (e instanceof Function)
        {
          final Function f = (Function) e;
          try
          {
            f.itemsFinished(event);
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
        else
        {
          try
          {
            if (e.isActive())
            {
              e.getValue();
            }
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
      }
    }
  }

  /**
   * Receives notification that a new row has been read.
   * <P>
   * This event is raised before an ItemBand is printed.
   *
   * @param event  the event.
   */
  public void itemsAdvanced(final ReportEvent event)
  {
    // clearError(); done in the prepare event ...

    for (int i = 0; i < levels.length; i++)
    {
      final int level = levels[i];
      if (level < getLevel())
      {
        break;
      }
      final Object[] itLevel = levelData[i];
      for (int l = 0; l < itLevel.length; l++)
      {
        final Expression e = (Expression) itLevel[l];
        if (e instanceof Function)
        {
          final Function f = (Function) e;
          try
          {
            f.itemsAdvanced(event);
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
        else
        {
          try
          {
            if (e.isActive())
            {
              e.getValue();
            }
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
      }
    }
  }

  /**
   * Receives notification that the band layouting has completed.
   * <P>
   * The event carries the current report state.
   *
   * @param event The event.
   */
  public void layoutComplete(final LayoutEvent event)
  {
    // this is an internal event, no need to handle prepare outside ..
    // clearError();
    firePrepareEventLayoutListener(event);

    for (int i = 0; i < levels.length; i++)
    {
      final int level = levels[i];
      if (level < getLevel())
      {
        break;
      }
      final Object[] itLevel = levelData[i];
      for (int l = 0; l < itLevel.length; l++)
      {
        final Expression e = (Expression) itLevel[l];
        if (e instanceof LayoutListener && e instanceof Function)
        {
          final LayoutListener f = (LayoutListener) e;
          try
          {
            f.layoutComplete(event);
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
      }
    }
  }

  /**
   * Receives notification that report generation has completed, the report footer was printed,
   * no more output is done. This is a helper event to shut down the output service.
   *
   * @param event The event.
   */
  public void reportDone(final ReportEvent event)
  {
    // clearError(); done in the prepare event ...

    for (int i = 0; i < levels.length; i++)
    {
      final int level = levels[i];
      if (level < getLevel())
      {
        break;
      }
      final Object[] itLevel = levelData[i];
      for (int l = 0; l < itLevel.length; l++)
      {
        final Expression e = (Expression) itLevel[l];
        if (e instanceof Function)
        {
          final Function f = (Function) e;
          try
          {
            f.reportDone(event);
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
        else
        {
          try
          {
            if (e.isActive())
            {
              e.getValue();
            }
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
      }
    }
  }

  /**
   * Connects the given datarow to the expression collection and all expressions contained in
   * this collection.
   *
   * @param dr  the datarow to be connected (null not permitted).
   *
   * @throws IllegalStateException if there is a datarow already connected.
   * @throws NullPointerException if the given datarow is null.
   */
  public void setDataRow(final DataRow dr)
  {
    if (dr != null && dataRow != null)
    {
      // be paranoid and make sure that we dont replace the datarow
      // by accident
      throw new IllegalStateException
          ("Paranoia: Update calls must be done using the updateDataRow method.");
    }
    updateDataRow(dr);
  }

  /**
   * Updates the datarow for all expressions. Does not perform validity
   * checks, so use this function with care.
   *
   * @param dr  the datarow to be connected.
   *
   * @throws NullPointerException if the given datarow is null.
   * @throws IllegalStateException if there is no datarow connected.
   */
  public void updateDataRow(final DataRow dr)
  {
    dataRow = dr;
    for (int i = 0; i < levelData.length; i++)
    {
      for (int j = 0; j < levelData[i].length; j++)
      {
        final Expression f = levelData[i][j];
        f.setDataRow(dr);
      }
    }
  }

  /**
   * Returns the currently connected dataRow.
   *
   * @return the dataRow.
   */
  public DataRow getDataRow()
  {
    return dataRow;
  }

  /**
   * Initialises the expressions.
   *
   * @param expressionCollection  the expression collection.
   * @param functionCollection the function collection.
   */
  private void initialize(final ExpressionCollection expressionCollection,
                          final ExpressionCollection functionCollection)
  {
    final LevelList expressionList = new LevelList();

    int size = expressionCollection.size();
    for (int i = 0; i < size; i++)
    {
      Expression f = expressionCollection.getExpression(i);
      if (f != null)
      {
        f = f.getInstance();
        expressionList.add(f);
        expressionList.setLevel(f, f.getDependencyLevel());
      }
    }
    if (functionCollection != null)
    {
      size = functionCollection.size();
      for (int i = 0; i < size; i++)
      {
        // Explicit cast to Function to test all contained elements to be Functions!
        // this may be just paranoid.
        // todo 090 next redesign should unify functions and expressions in the
        // report object.
        Function f = (Function) functionCollection.getExpression(i);
        if (f != null)
        {
          f = (Function) f.getInstance();
          expressionList.add(f);
          expressionList.setLevel(f, f.getDependencyLevel());
        }
      }
    }
    initializeFromLevelList(expressionList);
  }

  /**
   * Initializes the expression list from the given levellist.
   * 
   * @param expressionList the list containing the expressions and 
   * functions.
   */
  private void initializeFromLevelList (final LevelList expressionList)
  {
    this.size = 0;
    this.levels = buildLevels(expressionList);
    this.levelData = new Expression[levels.length][];
    this.flatData = new Expression[expressionList.size()];

    for (int i = 0; i < levels.length; i++)
    {
      final int currentLevel = levels[i];
      final Expression[] data = (Expression[])
          expressionList.getElementArrayForLevel(currentLevel,
          new Expression[expressionList.getElementCountForLevel(currentLevel)]);

      this.levelData[i] = data;
      System.arraycopy(data, 0, this.flatData, this.size, data.length);
      this.size += data.length;
    }
  }

  /**
   * Size does not change, so it is cached.
   *
   * @return the size.
   */
  public int size()
  {
    return size;
  }

  /**
   * Creates and returns a copy of this object.  The precise meaning
   * of "copy" may depend on the class of the object.
   * <p>
   * The cloned LevelledExpressionList will no longer be connected to
   * a datarow.
   *
   * @return     a clone of this instance.
   * @exception  CloneNotSupportedException  if the object's class does not
   *               support the <code>Cloneable</code> interface.
   * @exception  OutOfMemoryError            if there is not enough memory.
   * @see        java.lang.Cloneable
   */
  public Object clone() throws CloneNotSupportedException
  {
    final LevelledExpressionList ft = (LevelledExpressionList) super.clone();
    // ft.levels = levels; // no need to clone them ...
    // ft.size = size;     // already copied during cloning ...
    ft.dataRow = null;
    ft.errorList = (ArrayList) errorList.clone();
    ft.levelData = new Expression[levelData.length][];
    ft.flatData = new Expression[flatData.length];

    int flatDataPos = 0;
    for (int level = 0; level < levelData.length; level++)
    {
      ft.levelData[level] = new Expression[levelData[level].length];
      for (int i = 0; i < levelData[level].length; i++)
      {
        final Expression ex = levelData[level][i];
        if (ex instanceof Function)
        {
          final Expression exClone = (Expression) ex.clone();
          exClone.setDataRow(null);
          ft.levelData[level][i] = exClone;
          ft.flatData[flatDataPos] = exClone;
        }
        else
        {
          final Expression exClone = ex.getInstance();
          exClone.setDataRow(null);
          ft.levelData[level][i] = exClone;
          ft.flatData[flatDataPos] = exClone;
        }
        flatDataPos++;
      }
    }
    return ft;
  }

  /**
   * Returns the preview instance of the levelled expression list. This list
   * does no longer contain any Function instances.
   *  
   * @return the preview (expressions only) instance of the levelled expression list.
   */
  public LevelledExpressionList getPreviewInstance()
  {
    final LevelledExpressionList ft = new LevelledExpressionList();
    ft.errorList = new ArrayList();
    final LevelList expressionList = new LevelList();

    for (int level = 0; level < levelData.length; level++)
    {
      for (int i = 0; i < levelData[level].length; i++)
      {
        final Expression ex = levelData[level][i];
        if (ex instanceof Function)
        {
          // ignore it, functions are state dependent and cannot be used
          // to compute group changes ...
        }
        else
        {
          expressionList.add(ex.getInstance(), level);
        }
      }
    }
    ft.initializeFromLevelList(expressionList);
    return ft;
  }

  /**
   * Sets the level.
   *
   * @param level  the level.
   */
  public void setLevel(final int level)
  {
    this.level = level;
  }

  /**
   * Gets the current level.
   *
   * @return the current level.
   */
  public int getLevel()
  {
    return level;
  }

  /**
   * Returns an iterator that provides access to the levels in descending order.
   *
   * @return the iterator.
   */
  public Iterator getLevelsDescending()
  {
    final Integer[] levelIntegers = new Integer[levels.length];
    for (int i = 0; i < levels.length; i++)
    {
      levelIntegers[i] = new Integer(levels[i]);
    }
    return Collections.unmodifiableList(Arrays.asList(levelIntegers)).iterator();
  }

  /**
   * Returns an iterator that provides access to the levels in ascending order.
   *
   * @return the iterator.
   */
  public Iterator getLevelsAscending()
  {
    final Integer[] levelIntegers = new Integer[levels.length];
    for (int i = 0; i < levels.length; i++)
    {
      levelIntegers[levels.length - i - 1] = new Integer(levels[i]);
    }
    return Collections.unmodifiableList(Arrays.asList(levelIntegers)).iterator();
  }

  /**
   * Returns the values of an expression.
   *
   * @param index  the function/expression index.
   *
   * @return the value.
   */
  public Object getValue(final int index)
  {
    return flatData[index].getValue();
  }

  /**
   * Returns an expression.
   *
   * @param index  the function/expression index.
   *
   * @return the function/expression.
   */
  public Expression getExpression(final int index)
  {
    return flatData[index];
  }

  /**
   * Returns the list of errors, that occured during the last event handling.
   *
   * @return the list of errors.
   */
  public List getErrors()
  {
    return Collections.unmodifiableList(errorList);
  }

  /**
   * Returns true, if this list has detected at least one error in the last operation.
   *
   * @return true, if there were errors, false otherwise.
   */
  public boolean hasErrors()
  {
    return errorList.size() != 0;
  }

  /**
   * Adds the error to the current list of errors.
   *
   * @param e the new exception that occured during the event dispatching.
   */
  protected void addError(final Exception e)
  {
    errorList.add(e);
  }

  /**
   * Clears the error list.
   */
  protected void clearError()
  {
    errorList.clear();
  }

  /**
   * Fires a prepare event.
   *
   * @param event  the event.
   */
  public void firePrepareEvent(final ReportEvent event)
  {
    clearError();

    for (int i = 0; i < levels.length; i++)
    {
      final int level = levels[i];
      if (level < getLevel())
      {
        break;
      }
      final Object[] itLevel = levelData[i];
      for (int l = 0; l < itLevel.length; l++)
      {
        final Expression e = (Expression) itLevel[l];
        if (e instanceof Function && e instanceof PrepareEventListener)
        {
          final PrepareEventListener f = (PrepareEventListener) e;
          try
          {
            f.prepareEvent(event);
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
      }
    }
  }

  /**
   * Fires a prepare event layout listeners.
   *
   * @param event  the event.
   */
  protected void firePrepareEventLayoutListener(final ReportEvent event)
  {
    // no clear error here ...
    for (int i = 0; i < levels.length; i++)
    {
      final int level = levels[i];
      if (level < getLevel())
      {
        break;
      }
      final Object[] itLevel = levelData[i];
      for (int l = 0; l < itLevel.length; l++)
      {
        final Expression e = (Expression) itLevel[l];
        if (e instanceof Function && e instanceof PrepareEventListener
            && e instanceof LayoutListener)
        {
          final PrepareEventListener f = (PrepareEventListener) e;
          try
          {
            f.prepareEvent(event);
          }
          catch (Exception ex)
          {
            addError(ex);
          }
        }
      }
    }
  }
}