in endorsed/src/org.apache.sis.feature/main/org/apache/sis/feature/FeatureFormat.java [294:669]
public void format(final Object object, final Appendable toAppendTo) throws IOException {
ArgumentChecks.ensureNonNull("object", object);
ArgumentChecks.ensureNonNull("toAppendTo", toAppendTo);
/*
* Separate the Feature (optional) and the FeatureType (mandatory) instances.
*/
final DefaultFeatureType featureType;
final AbstractFeature feature;
if (object instanceof AbstractFeature) {
feature = (AbstractFeature) object;
featureType = feature.getType();
} else if (object instanceof DefaultFeatureType) {
featureType = (DefaultFeatureType) object;
feature = null;
} else {
throw new IllegalArgumentException(Errors.forLocale(displayLocale)
.getString(Errors.Keys.UnsupportedType_1, object.getClass()));
}
/*
* Computes the columns to show. We start with the set of columns specified by setAllowedColumns(Set),
* then we check if some of those columns are empty. For example, in many cases there are no attributes
* with characteritic, in which case we will ommit the whole "characteristics" column. We perform such
* check only for optional information, not for mandatory information like property names.
*/
final EnumSet<Column> visibleColumns = columns.clone();
{
boolean hasDesignation = false;
boolean hasCharacteristics = false;
boolean hasDeprecatedTypes = false;
for (final AbstractIdentifiedType propertyType : featureType.getProperties(true)) {
if (!hasDesignation) {
hasDesignation = propertyType.getDesignation().isPresent();
}
if (!hasCharacteristics && propertyType instanceof DefaultAttributeType<?>) {
hasCharacteristics = !((DefaultAttributeType<?>) propertyType).characteristics().isEmpty();
}
if (!hasDeprecatedTypes && propertyType instanceof Deprecable) {
hasDeprecatedTypes = ((Deprecable) propertyType).isDeprecated();
}
}
if (!hasDesignation) visibleColumns.remove(Column.DESIGNATION);
if (!hasCharacteristics) visibleColumns.remove(Column.CHARACTERISTICS);
if (!hasDeprecatedTypes) visibleColumns.remove(Column.REMARKS);
}
/*
* Format the feature type name. In the case of feature type, format also the names of super-type
* after the UML symbol for inheritance (an arrow with white head). We do not use the " : " ASCII
* character for avoiding confusion with the ":" separator in namespaces. After the feature (type)
* name, format the column header: property name, type, cardinality and (default) value.
*/
toAppendTo.append(toString(featureType.getName()));
if (feature == null) {
String separator = " ⇾ "; // UML symbol for inheritance.
for (final FeatureType parent : featureType.getSuperTypes()) {
toAppendTo.append(separator).append(toString(parent.getName()));
separator = SEPARATOR;
}
final InternationalString definition = featureType.getDefinition();
if (definition != null) {
final String text = Strings.trimOrNull(definition.toString(displayLocale));
if (text != null) {
toAppendTo.append(getLineSeparator()).append(text);
}
}
}
toAppendTo.append(getLineSeparator());
/*
* Create a table and format the header. Columns will be shown in Column enumeration order.
*/
final Vocabulary resources = Vocabulary.forLocale(displayLocale);
final var table = new TableAppender(toAppendTo, columnSeparator);
table.setMultiLinesCells(true);
table.nextLine('─');
boolean isFirstColumn = true;
for (final Column column : visibleColumns) {
short key = column.resourceKey;
if (feature == null) {
if (key == Vocabulary.Keys.Cardinality) key = Vocabulary.Keys.Multiplicity;
if (key == Vocabulary.Keys.Value) key = Vocabulary.Keys.DefaultValue;
}
if (!isFirstColumn) nextColumn(table);
table.append(resources.getString(key));
isFirstColumn = false;
}
table.nextLine();
table.nextLine('─');
/*
* Done writing the header. Now write all property rows. For each row, the first part in the loop
* extracts all information needed without formatting anything yet. If we detect in that part that
* a row has no value, it will be skipped if and only if that row is optional (minimum occurrence
* of zero).
*/
final var buffer = new StringBuffer();
final var dummyFP = new FieldPosition(-1);
final var remarks = new ArrayList<String>();
for (final AbstractIdentifiedType propertyType : featureType.getProperties(true)) {
Object value = null;
int cardinality = -1;
if (feature != null) {
if (!(propertyType instanceof DefaultAttributeType<?>) &&
!(propertyType instanceof DefaultAssociationRole) &&
!DefaultFeatureType.isParameterlessOperation(propertyType))
{
continue;
}
value = feature.getPropertyValue(propertyType.getName().toString());
if (value == null) {
if (propertyType instanceof DefaultAttributeType<?>
&& ((DefaultAttributeType<?>) propertyType).getMinimumOccurs() == 0
&& ((DefaultAttributeType<?>) propertyType).characteristics().isEmpty())
{
continue; // If optional, no value and no characteristics, skip the full row.
}
if (propertyType instanceof DefaultAssociationRole
&& ((DefaultAssociationRole) propertyType).getMinimumOccurs() == 0)
{
continue; // If optional and no value, skip the full row.
}
cardinality = 0;
} else if (value instanceof Collection<?>) {
cardinality = ((Collection<?>) value).size();
} else {
cardinality = 1;
}
} else if (propertyType instanceof DefaultAttributeType<?>) {
value = ((DefaultAttributeType<?>) propertyType).getDefaultValue();
} else if (propertyType instanceof AbstractOperation) {
buffer.append(" = ");
try {
((AbstractOperation) propertyType).formatResultFormula(buffer);
} catch (IOException e) {
throw new UncheckedIOException(e); // Should never happen since we write in a StringBuffer.
}
value = CharSequences.trimWhitespaces(buffer).toString();
buffer.setLength(0);
}
final String valueType; // The value to write in the type column.
final Class<?> valueClass; // AttributeType.getValueClass() if applicable.
final int minimumOccurs, maximumOccurs; // Negative values mean no cardinality.
final AbstractIdentifiedType resultType; // Result of operation if applicable.
if (propertyType instanceof AbstractOperation) {
resultType = ((AbstractOperation) propertyType).getResult(); // May be null
} else {
resultType = propertyType;
}
if (resultType instanceof DefaultAttributeType<?>) {
final DefaultAttributeType<?> pt = (DefaultAttributeType<?>) resultType;
minimumOccurs = pt.getMinimumOccurs();
maximumOccurs = pt.getMaximumOccurs();
valueClass = pt.getValueClass();
valueType = getFormat(Class.class).format(valueClass, buffer, dummyFP).toString();
buffer.setLength(0);
} else if (resultType instanceof DefaultAssociationRole) {
final DefaultAssociationRole pt = (DefaultAssociationRole) resultType;
minimumOccurs = pt.getMinimumOccurs();
maximumOccurs = pt.getMaximumOccurs();
valueType = toString(DefaultAssociationRole.getValueTypeName(pt));
valueClass = AbstractFeature.class;
} else {
valueType = (resultType != null) ? toString(resultType.getName()) : "";
valueClass = null;
minimumOccurs = -1;
maximumOccurs = -1;
}
/*
* At this point we determined that the row should not be skipped
* and we got all information to format.
*/
isFirstColumn = true;
for (final Column column : visibleColumns) {
if (!isFirstColumn) nextColumn(table);
isFirstColumn = false;
switch (column) {
/*
* Human-readable name of the property. May contains any characters (spaces, ideographs, etc).
* In many cases, this information is not provided and the whole column is skipped.
*/
case DESIGNATION: {
propertyType.getDesignation().ifPresent((d) -> {
table.append(d.toString(displayLocale));
});
break;
}
/*
* Machine-readable name of the property (identifier). This information is mandatory.
* This name is usually shorter than the designation and should contain only valid
* Unicode identifier characters (e.g. no spaces).
*/
case NAME: {
table.append(toString(propertyType.getName()));
break;
}
/*
* The base class or interface for all values in properties of the same type.
* This is typically String, Number, Integer, Geometry or URL.
*/
case TYPE: {
table.append(valueType);
break;
}
/*
* Minimum and maximum number of occurrences allowed for this property.
* If we are formatting a Feature instead of a FeatureType, then the
* actual number of values is also formatted. Example: 42 ∈ [0 … ∞]
*/
case CARDINALITY: {
table.setCellAlignment(TableAppender.ALIGN_RIGHT);
if (cardinality >= 0) {
table.append(getFormat(Integer.class).format(cardinality, buffer, dummyFP));
buffer.setLength(0);
}
if (maximumOccurs >= 0) {
if (cardinality >= 0) {
table.append(' ')
.append((cardinality >= minimumOccurs && cardinality <= maximumOccurs) ? '∈' : '∉')
.append(' ');
}
final Format format = getFormat(Integer.class);
table.append('[').append(format.format(minimumOccurs, buffer, dummyFP)).append(" … ");
buffer.setLength(0);
if (maximumOccurs != Integer.MAX_VALUE) {
table.append(format.format(maximumOccurs, buffer, dummyFP));
} else {
table.append('∞');
}
buffer.setLength(0);
table.append(']');
}
break;
}
/*
* If formatting a FeatureType, the default value. If formatting a Feature, the actual value.
* A java.text.Format instance dedicated to the value class is used if possible. In addition
* to types for which a java.text.Format may be available, we also have to check for other
* special cases. If there is more than one value, they are formatted as a coma-separated list.
*/
case VALUE: {
table.setCellAlignment(TableAppender.ALIGN_LEFT);
final Format format = getFormat(valueClass); // Null if valueClass is null.
final Iterator<?> it = CollectionsExt.toCollection(value).iterator();
String separator = "";
int length = 0;
while (it.hasNext()) {
value = it.next();
if (value != null) {
if (propertyType instanceof DefaultAssociationRole) {
final String p = DefaultAssociationRole.getTitleProperty((DefaultAssociationRole) propertyType);
if (p != null) {
value = ((AbstractFeature) value).getPropertyValue(p);
if (value == null) continue;
}
} else if (format != null && valueClass.isInstance(value)) { // Null safe because of getFormat(valueClass) contract.
/*
* Convert numbers, dates, angles, etc. to character sequences before to append them in the table.
* Note that DecimalFormat writes Not-a-Number as "NaN" in some locales and as "�" in other locales
* (U+FFFD - Unicode replacement character). The "�" seems to be used mostly for historical reasons;
* as of 2017 the Unicode Common Locale Data Repository (CLDR) seems to define "NaN" for all locales.
* We could configure DecimalFormatSymbols for using "NaN", but (for now) we rather substitute "�" by
* "NaN" here for avoiding to change the DecimalFormat configuration and for distinguishing the NaNs.
*/
final StringBuffer t = format.format(value, buffer, dummyFP);
if (value instanceof Number) {
final float f = ((Number) value).floatValue();
if (Float.isNaN(f)) {
if ("�".contentEquals(t)) {
t.setLength(0);
t.append("NaN");
}
try {
final int n = MathFunctions.toNanOrdinal(f);
if (n > 0) t.append(" #").append(n);
} catch (IllegalArgumentException e) {
// May happen if the NaN is a signaling NaN instead of a quiet NaN.
final int bits = Float.floatToRawIntBits(f);
if (bits != illegalNaN) {
illegalNaN = bits;
Logging.recoverableException(AbstractIdentifiedType.LOGGER, FeatureFormat.class, "format", e);
}
}
}
}
value = t;
}
/*
* All values: the numbers, dates, angles, etc. formatted above, any other character sequences
* (e.g. InternationalString), or other kind of values - some of them handled in a special way.
*/
length = formatValue(value, table.append(separator), length);
buffer.setLength(0);
if (length < 0) break; // Value is too long, abandon remaining iterations.
separator = SEPARATOR;
length += SEPARATOR.length();
}
}
break;
}
/*
* Characteristics are optional information attached to some values. For example if a property
* value is a temperature measurement, a characteritic of that value may be the unit of measure.
* Characteristics are handled as "attributes of attributes".
*/
case CHARACTERISTICS: {
if (propertyType instanceof DefaultAttributeType<?>) {
int length = 0;
String separator = "";
format: for (final DefaultAttributeType<?> ct : ((DefaultAttributeType<?>) propertyType).characteristics().values()) {
/*
* Format the characteristic name. We will append the value(s) later.
* We keep trace of the text length in order to stop formatting if the
* text become too long.
*/
final GenericName cn = ct.getName();
final String cs = toString(cn);
table.append(separator).append(cs);
length += separator.length() + cs.length();
Collection<?> cv = CollectionsExt.singletonOrEmpty(ct.getDefaultValue());
if (feature != null) {
/*
* Usually, the property `cp` below is null because all features use the same
* characteristic value (for example the same unit of measurement), which is
* given by the default value `cv`. Nevertheless we have to check if current
* feature overrides this characteristic.
*/
final Object cp = feature.getProperty(propertyType.getName().toString());
if (cp instanceof AbstractAttribute<?>) { // Should always be true, but we are paranoiac.
AbstractAttribute<?> ca = ((AbstractAttribute<?>) cp).characteristics().get(cn.toString());
if (ca != null) cv = ca.getValues();
}
}
/*
* Now format the value, separated from the name with " = ". Example: unit = m/s
* If the value accepts multi-occurrences, we will format the value between {…}.
* We use {…} because we may have more than one characteristic in the same cell,
* so we need a way to distinguish multi-values from multi-characteristics.
*/
final boolean multi = ct.getMaximumOccurs() > 1;
String sep = multi ? " = {" : " = ";
for (Object c : cv) {
length = formatValue(c, table.append(sep), length += sep.length());
if (length < 0) break format; // Value is too long, abandon remaining iterations.
sep = SEPARATOR;
}
separator = SEPARATOR;
if (multi && sep == SEPARATOR) {
table.append('}');
}
}
}
break;
}
case REMARKS: {
if (org.apache.sis.feature.Field.isDeprecated(propertyType)) {
table.append(resources.getString(Vocabulary.Keys.Deprecated));
final InternationalString r = ((Deprecable) propertyType).getRemarks();
if (r != null) {
remarks.add(r.toString(displayLocale));
appendSuperscript(remarks.size(), table);
}
}
break;
}
}
}
table.nextLine();
}
table.nextLine('─');
table.flush();
/*
* If there is any remarks, write them below the table.
*/
final int n = remarks.size();
for (int i=0; i<n; i++) {
appendSuperscript(i+1, toAppendTo);
toAppendTo.append(' ').append(remarks.get(i)).append(lineSeparator);
}
}