/// <summary>
/// Assigns field readers to report fields.
/// </summary>
/// <param name="useIndexOnSingleReturn"> whether to use indexed addressing even when the query has only one return column </param>
/// <returns> a report field name to field reader mapping </returns>
/// <seealso cref= FieldReader </seealso>
protected internal virtual IDictionary <string, FieldReader> assignReaders(bool useIndexOnSingleReturn)
{
IDictionary <string, FieldReader> readers = new Dictionary <string, FieldReader>();
JRField[] fields = queryExecuter.Dataset.Fields;
Type[] returnTypes = queryExecuter.ReturnTypes;
string[] aliases = queryExecuter.ReturnAliases;
IDictionary <string, int> aliasesMap = new Dictionary <string, int>();
if (aliases != null)
{
for (int i = 0; i < aliases.Length; i++)
{
aliasesMap[aliases[i]] = Convert.ToInt32(i);
}
}
if (returnTypes.Length == 1)
{
if (returnTypes[0].EntityType || returnTypes[0].ComponentType)
{
for (int i = 0; i < fields.Length; i++)
{
JRField field = fields[i];
readers[field.Name] = getFieldReaderSingleReturn(aliasesMap, field, useIndexOnSingleReturn);
}
}
else
{
if (fields.Length > 1)
{
throw new JRRuntimeException("The HQL query returns only one non-entity and non-component result but there are more than one fields.");
}
if (fields.Length == 1)
{
JRField field = fields[0];
if (useIndexOnSingleReturn)
{
readers[field.Name] = new IndexFieldReader(0);
}
else
{
readers[field.Name] = new IdentityFieldReader();
}
}
}
}
else
{
for (int i = 0; i < fields.Length; i++)
{
JRField field = fields[i];
readers[field.Name] = getFieldReader(returnTypes, aliasesMap, field);
}
}
return(readers);
}
public string getPropertyName(JRField field)
{
if (field.Description == null)
{
return(field.Name);
}
return(field.Description);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: @Override public Object getFieldValue(net.sf.jasperreports.engine.JRField jrField) throws net.sf.jasperreports.engine.JRException
public override object getFieldValue(JRField jrField)
{
FieldReader reader = fieldReaders[jrField.Name];
if (reader == null)
{
throw new JRRuntimeException("No filed reader for " + jrField.Name);
}
return(reader.getFieldValue(currentReturnValue));
}
public string getPropertyName(JRField field)
{
return(field.Name);
}
protected internal virtual string getFieldMapping(JRField field)
{
return((useFieldDescription ? FIELD_DESCRIPTION_PROPERTY_NAME_PROVIDER : FIELD_NAME_PROPERTY_NAME_PROVIDER).getPropertyName(field));
}
protected internal virtual FieldReader getFieldReader(Type[] returnTypes, IDictionary <string, int> aliasesMap, JRField field)
{
FieldReader reader;
string fieldMapping = getFieldMapping(field);
int? fieldIdx = aliasesMap[fieldMapping];
if (fieldIdx == null)
{
int firstNestedIdx = fieldMapping.IndexOf(PropertyUtils.NESTED_DELIM);
if (firstNestedIdx < 0)
{
throw new JRRuntimeException("Unknown HQL return alias \"" + fieldMapping + "\".");
}
string fieldAlias = fieldMapping.Substring(0, firstNestedIdx);
string fieldProperty = fieldMapping.Substring(firstNestedIdx + 1);
fieldIdx = aliasesMap[fieldAlias];
if (fieldIdx == null)
{
throw new JRRuntimeException("The HQL query does not have a \"" + fieldAlias + "\" alias.");
}
Type type = returnTypes[fieldIdx.Value];
if (!type.EntityType && !type.ComponentType)
{
throw new JRRuntimeException("The HQL query does not have a \"" + fieldAlias + "\" alias.");
}
reader = new IndexPropertyFieldReader(fieldIdx.Value, fieldProperty);
}
else
{
reader = new IndexFieldReader(fieldIdx.Value);
}
return(reader);
}
protected internal virtual FieldReader getFieldReaderSingleReturn(IDictionary <string, int> aliasesMap, JRField field, bool useIndex)
{
FieldReader reader;
string fieldMapping = getFieldMapping(field);
if (aliasesMap.ContainsKey(fieldMapping))
{
if (useIndex)
{
reader = new IndexFieldReader(0);
}
else
{
reader = new IdentityFieldReader();
}
}
else
{
int firstNestedIdx = fieldMapping.IndexOf(PropertyUtils.NESTED_DELIM);
if (firstNestedIdx >= 0 && aliasesMap.ContainsKey(fieldMapping.Substring(0, firstNestedIdx)))
{
fieldMapping = fieldMapping.Substring(firstNestedIdx + 1);
}
if (useIndex)
{
reader = new IndexPropertyFieldReader(0, fieldMapping);
}
else
{
reader = new PropertyFieldReader(fieldMapping);
}
}
return(reader);
}
