* Example on how to use: * *
* static class Record
* {
* int i;
*
* String s;
*
* HDF5EnumerationValue e;
*
* Record(int i, String s, HDF5EnumerationValue e)
* {
* this.i = i;
* this.e = e;
* this.s = s;
* }
*
* Record()
* {
* }
*
* static HDF5CompoundType<Record> getHDF5Type(HDF5Reader reader)
* {
* final HDF5EnumerationType enumType = reader.getEnumType("someEnumType", new String[]
* { "1", "Two", "THREE" });
* return reader.getCompoundType(Record.class, mapping("i"),
* mapping("s", 20), mapping("e", enumType));
* }
*
* }
*
* ...
*
* final HDF5Writer writer = new HDF5Writer(new File("test.h5").open();
* final HDF5CompoundType<Record> compoundType = Record.getHDF5Type(writer);
* final HDF5EnumerationType enumType = writer.getEnumType("someEnumType");
* Record[] array =
* new Record[]
* {
* new Record(1, "some text",
* new HDF5EnumerationValue(enumType, "THREE")),
* new Record(2, "some note",
* new HDF5EnumerationValue(enumType, "1")), };
* writer.writeCompound("/testCompound", compoundType, recordWritten);
* writer.close();
*
*
* A simpler form is to let JHDF5 infer the mapping between fields in the Java object and members of
* the compound data type, see {@link #inferMapping(Class)} and {@link #inferMapping(Class, Map)}
*
* @author Bernd Rinn
*/
public final class HDF5CompoundMemberMapping
{
private final String memberName;
private final long storageDataTypeId;
private final Field fieldOrNull;
private String fieldName;
private Class memberClassOrNull;
private String enumTypeNameOrNull;
private int memberTypeLength;
private boolean unsigned;
private boolean variableLength;
private boolean reference;
private int[] memberTypeDimensions;
private HDF5EnumerationType enumTypeOrNull;
private HDF5DataTypeVariant typeVariantOrNull;
private HDF5CompoundMappingHints hintsOrNull;
/**
* Adds a member mapping for memberName.
*
* @param memberName The name of the member in the compound type. field in the Java class. Will
* also be used to find the name of the field in the Java class if not overridden by
* {@link #fieldName(String)}.
*/
public static HDF5CompoundMemberMapping mapping(String memberName)
{
return new HDF5CompoundMemberMapping(memberName);
}
/**
* Adds a member mapping for fieldName.
*
* @param fieldName The name of the field in the Java class.
* @param memberName The name of the member in the compound type.
* @param memberClass The class of the member. Only used if the compound pojo class is a map.
* For restrictions on the type, see above.
* @param memberDimensions The dimensions of the compound type (i.e. length of the String or
* dimensions of the array).
* @param storageDataTypeId The storage data type id of the member, if known, or -1 else
* @param unsigned If true, map to an unsigned integer type.
* @param variableLength if true, map to a variable-length string type.
* @param reference if true, map to a reference type.
* @param typeVariantOrNull The data type variant of this mapping or null
*/
static HDF5CompoundMemberMapping mappingArrayWithStorageId(String fieldName, String memberName,
Class memberClass, int[] memberDimensions, long storageDataTypeId, boolean unsigned,
boolean variableLength, boolean reference, HDF5DataTypeVariant typeVariantOrNull)
{
return new HDF5CompoundMemberMapping(fieldName, null, memberClass, memberName, null, null,
memberDimensions, storageDataTypeId, unsigned, variableLength, reference,
typeVariantOrNull);
}
/**
* Adds a member mapping for fieldName. Only suitable for Enumeration arrays.
*
* @param fieldName The name of the field in the Java class.
* @param memberName The name of the member in the compound type.
* @param enumType The enumeration type in the HDF5 file.
* @param memberTypeDimensions The dimensions of the array in the compound type.
* @param storageTypeId the id of the storage type of this member.
* @param typeVariantOrNull The data type variant of this mapping or null
*/
static HDF5CompoundMemberMapping mappingWithStorageTypeId(String fieldName, String memberName,
HDF5EnumerationType enumType, int[] memberTypeDimensions, long storageTypeId,
HDF5DataTypeVariant typeVariantOrNull)
{
assert enumType != null;
return new HDF5CompoundMemberMapping(fieldName, null, HDF5EnumerationValueArray.class,
memberName, enumType, null, memberTypeDimensions, storageTypeId, false, false,
false, typeVariantOrNull);
}
/**
* Returns the inferred compound member mapping for the given pojoClass. This method
* honors the annotations {@link CompoundType} and {@link CompoundElement}.
*
* Note 1: All fields that correspond to members with a variable length (e.g. Strings,
* primitive arrays and matrices and objects of type MDXXXArray) need to be
* annotated with {@link CompoundElement} specifying their dimensions using
* {@link CompoundElement#dimensions()}. .
*
* Note 2: pojoClass containing HDF5 enumerations cannot have their mapping * inferred as the HDF5 enumeration type needs to be explicitly specified in the mapping. *
* Example 1: * *
* class Record1
* {
* @CompoundElement(dimension = 10)
* String s;
*
* float f;
* }
*
*
* will lead to:
*
*
* inferMapping(Record1.class) -> { mapping("s", 10), mapping("f") }
*
*
* Example 2:
*
*
* @CompoundType(mapAllFields = false)
* class Record2
* {
* @CompoundElement(memberName = "someString", dimension = 10)
* String s;
*
* float f;
* }
*
*
* will lead to:
*
*
* inferMapping(Record2.class) -> { mapping("s", "someString", 10) }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Class pojoClass)
{
return inferMapping(pojoClass, (HDF5CompoundMappingHints) null);
}
/**
* Returns the inferred compound member mapping for the given pojoClass. This method
* honors the annotations {@link CompoundType} and {@link CompoundElement}.
*
* Note 1: All fields that correspond to members with a dimension (e.g. Strings,
* primitive arrays and matrices and objects of type MDXXXArray) need to be
* annotated with {@link CompoundElement} specifying their dimensions using
* {@link CompoundElement#dimensions()}. Strings can alternatively also be annotated as
* CompoundElement.variableLength = true.
*
* Note 2: pojoClass containing HDF5 enumerations need to have their * {@link HDF5EnumerationType} specified in the fieldNameToEnumTypeMapOrNull. You may * use {@link #inferEnumerationTypeMap(Object, IHDF5EnumTypeRetriever)} to create * fieldNameToEnumTypeMapOrNull. *
* Example 1: * *
* class Record1
* {
* @CompoundElement(dimension = 10)
* String s;
*
* float f;
* }
*
*
* will lead to:
*
*
* inferMapping(Record1.class) -> { mapping("s", 10), mapping("f") }
*
*
* Example 2:
*
*
* @CompoundType(mapAllFields = false)
* class Record2
* {
* @CompoundElement(memberName = "someString", dimension = 10)
* String s;
*
* float f;
* }
*
*
* will lead to:
*
*
* inferMapping(Record2.class) -> { mapping("s", "someString", 10) }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Class pojoClass,
final Map
* Note 1: All fields that correspond to members with a dimension (e.g. Strings,
* primitive arrays and matrices and objects of type MDXXXArray) need to be
* annotated with {@link CompoundElement} specifying their dimensions using
* {@link CompoundElement#dimensions()}. Strings can alternatively also be annotated as
* CompoundElement.variableLength = true.
*
* Note 2: pojoClass containing HDF5 enumerations need to have their * {@link HDF5EnumerationType} specified in the fieldNameToEnumTypeMapOrNull. You may * use {@link #inferEnumerationTypeMap(Object, IHDF5EnumTypeRetriever)} to create * fieldNameToEnumTypeMapOrNull. *
* Example 1: * *
* class Record1
* {
* @CompoundElement(dimension = 10)
* String s;
*
* float f;
* }
*
*
* will lead to:
*
*
* inferMapping(Record1.class) -> { mapping("s", 10), mapping("f") }
*
*
* Example 2:
*
*
* @CompoundType(mapAllFields = false)
* class Record2
* {
* @CompoundElement(memberName = "someString", dimension = 10)
* String s;
*
* float f;
* }
*
*
* will lead to:
*
*
* inferMapping(Record2.class) -> { mapping("s", "someString", 10) }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Class pojoClass,
final HDF5CompoundMappingHints hintsOrNull)
{
final List
* This method is using pojo to infer length and dimension information.
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Object pojo,
final Map
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Object pojo,
final Map
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Object[] pojo,
final Map
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Object[] pojo,
final Map
* Example:
*
*
* Example:
*
*
* Example:
*
*
* Example:
*
*
* Example:
*
*
* Example:
*
* true, use variable-length string types
* for all strings in the pojo template.
* @see #inferMapping(Class, Map) true, use variable-length string types
* for all strings in the pojo template.
* @see #inferMapping(Class, Map)
* Map<String, Object> mw = new HashMap<String, Object>();
* mw.put("date", new Date());
* mw.put("temperatureInDegreeCelsius", 19.5f);
* mw.put("voltagesInMilliVolts", new double[][] { 1, 2, 3 }, { 4, 5, 6 } });
*
*
* will lead to:
*
*
* inferMapping(mw) -> { mapping("date").memberClass(Date.class),
* mapping("temperatureInDegreeCelsius").memberClass(float.class),
* mapping("voltagesInMilliVolts").memberClass(double[][].class).dimensions(new int[] { 3, 3 } }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Map
* Map<String, Object> mw = new HashMap<String, Object>();
* mw.put("date", new Date());
* mw.put("temperatureInDegreeCelsius", 19.5f);
* mw.put("voltagesInMilliVolts", new double[][] { 1, 2, 3 }, { 4, 5, 6 } });
*
*
* will lead to:
*
*
* inferMapping(mw) -> { mapping("date").memberClass(Date.class),
* mapping("temperatureInDegreeCelsius").memberClass(float.class),
* mapping("voltagesInMilliVolts").memberClass(double[][].class).dimensions(new int[] { 3, 3 } }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final Map
* List<String> n = Arrays.asList("date", "temperatureInDegreeCelsius", "voltagesInMilliVolts");
* List<Object> l = Arrays. <Object>asList(new Date(), 19.5f, new double[][] { 1, 2, 3 }, { 4, 5, 6 } });
*
*
* will lead to:
*
*
* inferMapping(n, l) -> { mapping("date").memberClass(Date.class),
* mapping("temperatureInDegreeCelsius").memberClass(float.class),
* mapping("voltagesInMilliVolts").memberClass(double[][].class).dimensions(new int[] { 3, 3 } }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final List
* List<String> n = Arrays.asList("date", "temperatureInDegreeCelsius", "voltagesInMilliVolts");
* List<Object> l = Arrays. <Object>asList(new Date(), 19.5f, new double[][] { 1, 2, 3 }, { 4, 5, 6 } });
*
*
* will lead to:
*
*
* inferMapping(n, l) -> { mapping("date").memberClass(Date.class),
* mapping("temperatureInDegreeCelsius").memberClass(float.class),
* mapping("voltagesInMilliVolts").memberClass(double[][].class).dimensions(new int[] { 3, 3 } }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final List
* String[] n = new String[] { "date", "temperatureInDegreeCelsius", "voltagesInMilliVolts" };
* Object[] l = new Object[] { new Date(), 19.5f, new double[][] { 1, 2, 3 }, { 4, 5, 6 } } };
*
*
* will lead to:
*
*
* inferMapping(n, l) -> { mapping("date").memberClass(Date.class),
* mapping("temperatureInDegreeCelsius").memberClass(float.class),
* mapping("voltagesInMilliVolts").memberClass(double[][].class).dimensions(new int[] { 3, 3 } }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final String[] memberNames,
final Object[] memberValues)
{
return inferMapping(memberNames, memberValues, (HDF5CompoundMappingHints) null);
}
/**
* Returns the inferred compound member mapping for the given memberNames and
* memberValues. All entries that correspond to members with length or dimension
* information take this information from the values supplied.
*
* String[] n = new String[] { "date", "temperatureInDegreeCelsius", "voltagesInMilliVolts" };
* Object[] l = new Object[] { new Date(), 19.5f, new double[][] { 1, 2, 3 }, { 4, 5, 6 } } };
*
*
* will lead to:
*
*
* inferMapping(n, l) -> { mapping("date").memberClass(Date.class),
* mapping("temperatureInDegreeCelsius").memberClass(float.class),
* mapping("voltagesInMilliVolts").memberClass(double[][].class).dimensions(new int[] { 3, 3 } }
*
*/
public static HDF5CompoundMemberMapping[] inferMapping(final String[] memberNames,
final Object[] memberValues, final HDF5CompoundMappingHints hints)
{
assert memberNames != null;
assert memberValues != null;
assert memberNames.length == memberValues.length;
final Listtrue, the names will be sorted before they are concatenated.
*/
public static String constructCompoundTypeName(final Collectiontrue, the type will be mapped to an unsigned integer type.
* @param typeVariantOrNull The data type variant of this mapping, or null if this
* mapping has no type variant.
*/
private HDF5CompoundMemberMapping(String fieldName, Class memberClassOrNull,
String memberName, HDF5EnumerationType enumTypeOrNull, String enumTypeNameOrNull,
int[] memberTypeDimensions, HDF5DataTypeVariant typeVariantOrNull)
{
this(fieldName, null, memberClassOrNull, memberName, enumTypeOrNull, enumTypeNameOrNull,
memberTypeDimensions, -1, false, false, false, typeVariantOrNull);
}
/**
* A {@link HDF5CompoundMemberMapping} that allows to provide an explicit memberName
* that differs from the fieldName and the maximal length in case of a String member.
*
* @param fieldName The name of the field in the clazz
* @param memberClassOrNull The class of the member, if a map is used as the compound pojo.
* @param memberName The name of the member in the HDF5 compound data type.
* @param enumTypeOrNull The HDF5 enumeration type of this member.
* @param enumTypeNameOrNull The name to be used for the HDF5 enumeration type.
* @param memberTypeDimensions The dimensions of the member type, or 0 for a scalar value.
* @param unsigned If true, the type will be mapped to an unsigned integer type.
* @param variableLength If true, the type will be mapped to a variable-length
* type.
* @param typeVariantOrNull The data type variant of this mapping, or null if this
* mapping has no type variant.
*/
private HDF5CompoundMemberMapping(String fieldName, Class memberClassOrNull,
String memberName, HDF5EnumerationType enumTypeOrNull, String enumTypeNameOrNull,
int[] memberTypeDimensions, boolean unsigned, boolean variableLength,
HDF5DataTypeVariant typeVariantOrNull)
{
this(fieldName, null, memberClassOrNull, memberName, enumTypeOrNull, enumTypeNameOrNull,
memberTypeDimensions, -1, unsigned, variableLength, false, typeVariantOrNull);
}
/**
* A {@link HDF5CompoundMemberMapping} that allows to provide an explicit memberName
* that differs from the fieldName and the maximal length in case of a String member.
*
* @param fieldName The name of the field in the clazz
* @param fieldOrNull The {@link Field} in the compound class (may be null)
* @param memberClassOrNull The class of the member, if a map is used as the compound pojo.
* @param memberName The name of the member in the HDF5 compound data type.
* @param enumTypeOrNull The HDF5 enumeration type of this member.
* @param enumTypeNameOrNull The name to be used for the HDF5 enumeration type.
* @param memberTypeDimensions The dimensions of the member type, or 0 for a scalar value.
* @param unsigned If true, the type will be mapped to an unsigned integer type.
* @param variableLength If true, the type will be mapped to a variable-length
* type.
* @param reference If true, the type will be mapped to a reference type. type.
* @param typeVariantOrNull The data type variant of this mapping, or null if this
* mapping has no type variant.
*/
private HDF5CompoundMemberMapping(String fieldName, Field fieldOrNull,
Class memberClassOrNull, String memberName, HDF5EnumerationType enumTypeOrNull,
String enumTypeNameOrNull, int[] memberTypeDimensions, boolean unsigned,
boolean variableLength, boolean reference, HDF5DataTypeVariant typeVariantOrNull)
{
this(fieldName, fieldOrNull, memberClassOrNull, memberName, enumTypeOrNull,
enumTypeNameOrNull, memberTypeDimensions, -1, unsigned, variableLength, reference,
typeVariantOrNull);
}
/**
* A {@link HDF5CompoundMemberMapping} that allows to provide an explicit memberName
* that differs from the fieldName and the maximal length in case of a String member.
*
* @param fieldName The name of the field in the clazz
* @param fieldOrNull The {@link Field} in the compound class (may be null)
* @param memberClassOrNull The class of the member, if a map is used as the compound pojo.
* @param memberName The name of the member in the HDF5 compound data type.
* @param enumTypeOrNull The enumeation type (only for enumerations, obviously).
* @param enumTypeNameOrNull The name of the committed HDF5 enum type.
* @param memberTypeDimensions The dimensions of the member type, or 0 for a scalar value.
* @param unsigned If true, the type will be mapped to an unsigned integer type.
* @param variableLength If true, the type will be mapped to a variable-length
* string type.
* @param reference If true, the type will be mapped to a reference type.
* @param storageMemberTypeId The storage data type id of member, or -1, if not available
*/
@SuppressWarnings("unlikely-arg-type")
private HDF5CompoundMemberMapping(String fieldName, Field fieldOrNull,
Class memberClassOrNull, String memberName, HDF5EnumerationType enumTypeOrNull,
String enumTypeNameOrNull, int[] memberTypeDimensions, long storageMemberTypeId,
boolean unsigned, boolean variableLength, boolean reference,
HDF5DataTypeVariant typeVariantOrNull)
{
this.fieldOrNull = fieldOrNull;
this.fieldName = fieldName;
this.memberClassOrNull = memberClassOrNull;
this.memberName = memberName;
this.enumTypeOrNull = enumTypeOrNull;
this.enumTypeNameOrNull = enumTypeNameOrNull;
this.memberTypeDimensions = memberTypeDimensions;
this.memberTypeLength = MDAbstractArray.getLength(memberTypeDimensions);
this.storageDataTypeId = storageMemberTypeId;
this.unsigned = unsigned;
this.variableLength = variableLength;
this.reference = reference;
this.typeVariantOrNull = typeVariantMap.get(typeVariantOrNull);
if (this.typeVariantOrNull == null)
{
this.typeVariantOrNull = HDF5DataTypeVariant.maskNull(typeVariantOrNull);
}
}
/**
* Sets the field name in the Java class to use for the mapping, overriding the member name
* which is used by default to find the field.
*/
@SuppressWarnings("hiding")
public HDF5CompoundMemberMapping fieldName(String fieldName)
{
this.fieldName = fieldName;
return this;
}
/**
* Sets the name to be used for the comitted HDF5 datatype (for Java enum types only, overriding
* the simple class name which is used by default as the type name.
*/
public HDF5CompoundMemberMapping enumTypeName(String enumTypeName)
{
this.enumTypeNameOrNull =
(enumTypeName != null && enumTypeName.length() == 0) ? null : enumTypeName;
return this;
}
String tryGetEnumTypeName()
{
return enumTypeNameOrNull;
}
Field tryGetField(Class clazz, boolean skipChecks) throws HDF5JavaException
{
return tryGetField(clazz, clazz, skipChecks);
}
Field tryGetField(Class clazz) throws HDF5JavaException
{
return tryGetField(clazz, clazz, false);
}
private Field tryGetField(Class clazz, Class searchClass, boolean skipChecks)
throws HDF5JavaException
{
try
{
final Field field = clazz.getDeclaredField(fieldName);
final boolean isArray = isArray(field);
if (skipChecks == false)
{
if (memberTypeLength > 1)
{
if (field.getType() != String.class && false == isArray)
{
throw new HDF5JavaException("Field '" + fieldName + "' of class '"
+ clazz.getCanonicalName()
+ "' is no String or array, but a length > 1 is given.");
}
} else if (memberTypeLength == 0 && (isFixedLengthString(field) || isArray))
{
throw new HDF5JavaException("Field '" + fieldName + "' of class '"
+ clazz.getCanonicalName()
+ "' is a String or array, but a length == 0 is given.");
}
}
return field;
} catch (NoSuchFieldException ex)
{
final Class superClassOrNull = clazz.getSuperclass();
if (superClassOrNull == null || superClassOrNull == Object.class)
{
return null;
} else
{
return tryGetField(superClassOrNull, searchClass, skipChecks);
}
}
}
private boolean isArray(final Field field)
{
final Class fieldType = field.getType();
return fieldType.isArray() || MDAbstractArray.class.isAssignableFrom(fieldType)
|| field.getType() == java.util.BitSet.class
|| field.getType() == HDF5EnumerationValueArray.class;
}
private boolean isFixedLengthString(final Field field)
{
return (field.getType() == String.class && false == variableLength && false == reference)
&& (hintsOrNull != null && false == hintsOrNull.isUseVariableLengthStrings());
}
String getMemberName()
{
return memberName;
}
/**
* Sets the member class to use for the mapping.
*/
public HDF5CompoundMemberMapping memberClass(Class memberClass)
{
this.memberClassOrNull = memberClass;
return this;
}
public Class tryGetMemberClass()
{
return memberClassOrNull;
}
/**
* Sets the length of the member type to use for the mapping. Must be set for String, BitSet.
* Can be used as a convenience method replacing {@link #dimensions(int[])} for array members of
* rank 1.
*/
@SuppressWarnings("hiding")
public HDF5CompoundMemberMapping length(int memberTypeLength)
{
return dimensions(new int[]
{ memberTypeLength });
}
int getMemberTypeLength()
{
return memberTypeLength;
}
/**
* Sets the dimensions of the member type to use for the mapping. Convenience method replacing
* {@link #dimensions(int[])} for array members of rank 2.
*/
public HDF5CompoundMemberMapping dimensions(int memberTypeDimensionX, int memberTypeDimensionY)
{
this.memberTypeDimensions = new int[]
{ memberTypeDimensionX, memberTypeDimensionY };
this.memberTypeLength = MDAbstractArray.getLength(memberTypeDimensions);
return this;
}
/**
* Sets the dimensions of the member type to use for the mapping. Must be set for array members
* of rank N.
*/
@SuppressWarnings("hiding")
public HDF5CompoundMemberMapping dimensions(int[] memberTypeDimensions)
{
this.memberTypeDimensions = memberTypeDimensions;
this.memberTypeLength = MDAbstractArray.getLength(memberTypeDimensions);
if (enumTypeOrNull != null)
{
checkEnumArrayRank();
this.memberClassOrNull = HDF5EnumerationValueArray.class;
}
return this;
}
/**
* Sets this field to an unsigned type. Must be an integer.
*/
public HDF5CompoundMemberMapping unsigned()
{
this.unsigned = true;
return this;
}
/**
* Sets this field to an unsigned type, if unsigned is true. Must be an
* integer.
*/
public HDF5CompoundMemberMapping unsigned(@SuppressWarnings("hiding")
boolean unsigned)
{
this.unsigned = unsigned;
return this;
}
/**
* Returns true if this field should be mapped to an unsigned integer.
*/
boolean isUnsigned()
{
return this.unsigned;
}
/**
* Sets this field to a variable-length type. Must be a string.
*/
public HDF5CompoundMemberMapping variableLength()
{
this.variableLength = true;
return this;
}
/**
* Sets this field to a variable-length type, if variableLength is true.
* Must be a string.
*/
public HDF5CompoundMemberMapping variableLength(@SuppressWarnings("hiding")
boolean variableLength)
{
this.variableLength = variableLength;
return this;
}
/**
* Returns true if this field should be mapped to a variable-length string.
*/
public boolean isVariableLength()
{
return this.variableLength;
}
/**
* Sets this field to a reference type. Must be a string.
*/
public HDF5CompoundMemberMapping reference()
{
this.reference = true;
return this;
}
/**
* Sets this field to a reference type, if reference is true. Must be a
* string.
*/
public HDF5CompoundMemberMapping reference(@SuppressWarnings("hiding")
boolean reference)
{
this.reference = reference;
return this;
}
/**
* Returns true if this field should be mapped to a refernce type.
*/
public boolean isReference()
{
return this.reference;
}
/**
* Sets mapping hints for this mapping.
*/
public HDF5CompoundMemberMapping hints(HDF5CompoundMappingHints hints)
{
this.hintsOrNull = hints;
return this;
}
private void checkEnumArrayRank()
{
if (memberTypeDimensions != null && memberTypeDimensions.length > 1)
{
throw new HDF5JavaException("Enumeration arrays only supported with rank 1 [rank="
+ memberTypeDimensions.length + "]");
}
}
int[] getMemberTypeDimensions()
{
return memberTypeDimensions;
}
long getStorageDataTypeId()
{
return storageDataTypeId;
}
/**
* Sets the enumeration type to use for the mapping. Must be set for enumeration members.
*/
public HDF5CompoundMemberMapping enumType(HDF5EnumerationType enumType)
{
this.enumTypeOrNull = enumType;
checkEnumArrayRank();
this.memberClassOrNull =
(memberTypeLength == 0) ? HDF5EnumerationValue.class
: HDF5EnumerationValueArray.class;
return this;
}
HDF5EnumerationType tryGetEnumerationType()
{
return enumTypeOrNull;
}
void setEnumerationType(HDF5EnumerationType enumType)
{
this.enumTypeOrNull = enumType;
}
HDF5CompoundMappingHints tryGetHints()
{
return hintsOrNull;
}
/**
* Sets the data type variant to use for the mapping.
*/
public HDF5CompoundMemberMapping typeVariant(HDF5DataTypeVariant typeVariant)
{
this.typeVariantOrNull = typeVariant;
return this;
}
HDF5DataTypeVariant tryGetTypeVariant()
{
return typeVariantOrNull;
}
}