I
- The initializer type used to build the many-to-one mappingK
- Type of the field identifier (key)C
- Type of the ComplexFieldMapEntry used. This is specified as a
parameter so we can provide type safety and polymorphism through a generic
interface on the one hand, and still extend specific implementations with
methods needed for that type of complex mapping without having to add every
such method to the generic interface.T
- The type of the beanpublic interface FieldMap<I,K extends Comparable<K>,C extends ComplexFieldMapEntry<I,K,T>,T>
BeanField
s.
Such a mapping requires a method of matching multiple fields. This method
will require data to initialize itself. Such a mapping also requires a key to
index the BeanField
that is to be provided for a match.Modifier and Type | Method and Description |
---|---|
String[] |
generateHeader(T bean)
This method generates a header that can be used for writing beans of the
type provided back to a file.
|
BeanField<T,K> |
get(K key)
Gets the
BeanField associated with this key. |
BeanField<T,K> |
put(K key,
BeanField<T,K> value)
Associates the given
BeanField with the given key . |
void |
putComplex(I initializer,
BeanField<T,K> value)
Adds a
BeanField to this map indexed by the data in
initializer . |
void |
setErrorLocale(Locale errorLocale)
Sets the locale to be used for error messages.
|
Collection<BeanField<T,K>> |
values()
Provides all values currently in the map.
|
String[] generateHeader(T bean) throws CsvRequiredFieldEmptyException
MappingStrategy
in use. The ordering of the
headers should be carefully considered by the implementing class.bean
- One perfect, shining example of how the bean to be written
should look. The most crucial thing is, for fields that result from
joining multiple fields on reading and thus need to be split on
writing, the MultiValuedMap
in
question must have the complete structure of the header to be
generated, even if some values are empty.CsvRequiredFieldEmptyException
- If a required header is missing
while attempting to write. Since every other header is hard-wired
through the bean fields and their associated annotations, this can only
happen with multi-valued fields.BeanField<T,K> get(K key)
BeanField
associated with this key.
If a key could possibly match both a regular, simple key (one added with
put(Comparable, BeanField)
), and a
complex key (one added with
putComplex(java.lang.Object, com.opencsv.bean.BeanField)
), the
simple key is always matched. If a key could match more than one complex
key, the return value is undefined.BeanField<T,K> put(K key, BeanField<T,K> value)
BeanField
with the given key
.void putComplex(I initializer, BeanField<T,K> value)
BeanField
to this map indexed by the data in
initializer
.
This is what makes this map special: It allows one to define
characteristics of a method to match multiple keys.initializer
- Whatever data the implementation needs to match
multiple keysvalue
- The BeanField
that is to be returned on a later
matchvoid setErrorLocale(Locale errorLocale)
errorLocale
- The locale to be used for error messagesCollection<BeanField<T,K>> values()
Copyright © 2005–2023. All rights reserved.