import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
/**
 * Receives notification that a row of data is being processed. Reads the data from the field defined for this function and hides the field if the value is equal to the last value and the this is not the first row of the item group.
 * 
 * @param event
 *          Information about the event.
 */
public void itemsAdvanced(final ReportEvent event) {
  DataRow dataRow = event.getDataRow();
  final Object fieldValue = dataRow.get(getField());
  // is visible when last and current object are not equal
  // first element in group is always visible
  if (firstInGroup == true) {
    visible = true;
    firstInGroup = false;
  } else {
    visible = (ObjectUtilities.equal(lastObject, fieldValue) == false);
  }
  lastObject = fieldValue;
  final Element e = event.getReport().getItemBand().getElement(getElement());
  if (e != null) {
    e.setVisible(visible);
  }
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
/**
 * Default Constructor.
 */
public QueryParametrizer(final DataRow parameters,
                         final Locale locale)
{
  if (locale == null)
  {
    throw new NullPointerException("Locale must not be null");
  }
  if (parameters == null)
  {
    throw new NullPointerException("Parameter datarow must not be null");
  }

  this.collectedFields = new LinkedHashSet<>();
  this.collectedParameter = new LinkedHashMap<>();
  this.parameters = parameters;
  this.locale = locale;
  setMarkerChar('$');
  setOpeningBraceChar('{');
  setClosingBraceChar('}');
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public Object getValue(final ExpressionRuntime runtime, final ReportElement element)
{
  // Elements can get their value from attributes directly, or can query a field and/or value via
  // the helper methods on the ElementTypeUtils class.
  final String message = ElementTypeUtils.getStringAttribute
      (element, SampleElementModule.NAMESPACE, TEMPLATE_STRING, "Hello, {0}");

  // The data-row grants access to all currently computed values. Use this to access fields from
  // the data-source or calculated measures from the named expressions and functions.
  final DataRow dataRow = runtime.getDataRow();
  final Object userName = dataRow.get("env::username");
  return MessageFormat.format(message, userName);
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public Object getValue(final ExpressionRuntime runtime, final ReportElement element)
{
  // Elements can get their value from attributes directly, or can query a field and/or value via
  // the helper methods on the ElementTypeUtils class.
  final String message = ElementTypeUtils.getStringAttribute
      (element, SampleElementModule.NAMESPACE, TEMPLATE_STRING, "Hello, {0}");

  // The data-row grants access to all currently computed values. Use this to access fields from
  // the data-source or calculated measures from the named expressions and functions.
  final DataRow dataRow = runtime.getDataRow();
  final Object userName = dataRow.get("env::username");
  final String textToPrint = MessageFormat.format(message, userName);

  final Object backgroundImageRaw = element.getAttribute(SampleElementModule.NAMESPACE, BACKGROUND_IMAGE);
  final Object image = filter(runtime, element, backgroundImageRaw);
  if (image instanceof DefaultImageReference)
  {
    return new SampleGraphicsDrawable(textToPrint, (DefaultImageReference) image);
  }
  else if (image instanceof DrawableWrapper)
  {
    return new SampleGraphicsDrawable(textToPrint, (DrawableWrapper) image);
  }
  else
  {
    return new SampleGraphicsDrawable(textToPrint);
  }
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public TableModel produce(final DataRow dataRow,
                          final DataFactoryContext dataFactoryContext) throws ReportDataFactoryException
{
  String backendQuery = (String) getParameter(BACKEND_QUERY);
  String displayName = (String) getParameter(ALL_PARAMETER_TEXT);
  String displayValue = (String) getParameter(ALL_PARAMETER_VALUE);

  TableModel tableModel = dataFactoryContext.getContextDataFactory().queryData(backendQuery, dataRow);
  if (tableModel.getColumnCount() < 1)
  {
    throw new ReportDataFactoryException("The base table-model has not enough columns");
  }

  try
  {
    TypedTableModel retval = new TypedTableModel();
    retval.addColumn(tableModel.getColumnName(0), tableModel.getColumnClass(0));
    retval.setValueAt(convertStringToTypedObject(displayValue, tableModel.getColumnClass(0)), 0, 0);
    for (int row = 0; row < tableModel.getRowCount(); row += 1)
    {
      retval.addRow(tableModel.getValueAt(row, 0));
    }

    if (tableModel.getColumnCount() > 1)
    {
      retval.addColumn(tableModel.getColumnName(1), tableModel.getColumnClass(1));
      retval.setValueAt(convertStringToTypedObject(displayName, tableModel.getColumnClass(1)), 0, 1);
      for (int row = 0; row < tableModel.getRowCount(); row += 1)
      {
        retval.setValueAt(tableModel.getValueAt(row, 1), row + 1, 1);
      }
    }
    return retval;
  }
  catch (BeanException be)
  {
    throw new ReportDataFactoryException("Failed to convert value to result-set type", be);
  }
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
protected String[] getReferencedFieldsInternal(final String query,
                                               final DataRow parameters) throws ReportDataFactoryException
{
  QueryParametrizer parametrizer = new QueryParametrizer(parameters, Locale.US);
  parametrizer.translateAndLookup(query);

  LinkedHashSet<String> collectedFields = parametrizer.getCollectedFields();
  return collectedFields.toArray(new String[collectedFields.size()]);
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
protected Object getQueryHashInternal(final String realQuery,
                                      final DataRow parameter) throws ReportDataFactoryException
{
  ArrayList<String> hash = new ArrayList<>();
  hash.add(realQuery);
  hash.add(urlPattern);
  return hash;

}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public String[] getReferencedFields(final DataFactoryMetaData dataFactoryMetaData,
                                    final DataFactory dataFactory,
                                    final String query,
                                    final DataRow dataRow)
{
  SampleDataFactory sampleDataFactory = (SampleDataFactory) dataFactory;
  return sampleDataFactory.getReferencedFields(query, dataRow);
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public ResourceReference[] getReferencedResources(final DataFactoryMetaData dataFactoryMetaData,
                                                  final DataFactory dataFactory,
                                                  final ResourceManager resourceManager,
                                                  final String query,
                                                  final DataRow dataRow)
{
  return new ResourceReference[0];
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public Object getQueryHash(final DataFactoryMetaData dataFactoryMetaData,
                           final DataFactory dataFactory,
                           final String query,
                           final DataRow dataRow)
{
  SampleDataFactory sampleDataFactory = (SampleDataFactory) dataFactory;
  return sampleDataFactory.getQueryHash(query, dataRow);
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public final TableModel queryData(final String query, final DataRow parameters) throws ReportDataFactoryException
{
  if (query == null)
  {
    throw new NullPointerException("Query is null."); //$NON-NLS-1$
  }
  final String realQuery = scriptingSupport.computeQuery(query, parameters);
  if (realQuery == null)
  {
    throw new ReportDataFactoryException("Query '" + query + "' is not recognized."); //$NON-NLS-1$ //$NON-NLS-2$
  }

  return queryDataInternal(realQuery, parameters);
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public final String[] getReferencedFields(final String query,
                                          final DataRow parameter)
{
  try
  {
    final String[] additionalFields = scriptingSupport.computeAdditionalQueryFields(query, parameter);
    if (additionalFields == null)
    {
      return null;
    }

    final String realQuery = scriptingSupport.computeQuery(query, parameter);
    if (realQuery == null)
    {
      throw new ReportDataFactoryException("Query '" + query + "' is not recognized."); //$NON-NLS-1$ //$NON-NLS-2$
    }

    String[] referencedFieldsInternal = getReferencedFieldsInternal(realQuery, parameter);
    if (referencedFieldsInternal == null)
    {
      return null;
    }

    final LinkedHashSet<String> fields = new LinkedHashSet<>();
    fields.addAll(Arrays.asList(referencedFieldsInternal));
    fields.addAll(Arrays.asList(additionalFields));
    return fields.toArray(new String[fields.size()]);
  }
  catch (ReportDataFactoryException rx)
  {
    logger.debug("Failed to compute referenced fields", rx); // NON-NLS
    return null;
  }
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public final Object getQueryHash(final String query, final DataRow parameter)
{
  try
  {
    final String realQuery = scriptingSupport.computeQuery(query, parameter);
    if (realQuery == null)
    {
      throw new ReportDataFactoryException("Query '" + query + "' is not recognized."); //$NON-NLS-1$ //$NON-NLS-2$
    }

    Object queryHashInternal = getQueryHashInternal(realQuery, parameter);
    if (queryHashInternal == null)
    {
      return null;
    }

    final ArrayList<Object> queryHash = new ArrayList<>();
    queryHash.add(getClass().getName());
    queryHash.add(queryHashInternal);
    queryHash.add(scriptingSupport.getScriptingLanguage(query));
    queryHash.add(scriptingSupport.getScript(query));
    return queryHash;
  }
  catch (ReportDataFactoryException rx)
  {
    logger.debug("Failed to compute query hash", rx); // NON-NLS
    return null;
  }
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public TransJobDrawable(DataRow dataRow, boolean pixelateImages) {
  this.dataRow = dataRow;
  this.pixelateImages = pixelateImages;
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
/**
 * @return the dataRow
 */
public DataRow getDataRow() {
  return dataRow;
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
/**
 * @param dataRow the dataRow to set
 */
public void setDataRow(DataRow dataRow) {
  this.dataRow = dataRow;
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public TransJobDrawable( DataRow dataRow, boolean pixelateImages ) {
  this.dataRow = dataRow;
  this.pixelateImages = pixelateImages;
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
public boolean isQueryExecutable(final String query, final DataRow dataRow)
{
  return scriptingSupport.containsQuery(query);
}
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
protected abstract String[] getReferencedFieldsInternal(final String query,
final DataRow parameters) throws ReportDataFactoryException;
 

import org.pentaho.reporting.engine.classic.core.DataRow; //导入依赖的package包/类
protected abstract Object getQueryHashInternal(final String realQuery,
final DataRow parameter) throws ReportDataFactoryException;