// Path: fixb/src/main/java/org/fixb/FixException.java
// public class FixException extends RuntimeException {
//     private static final long serialVersionUID = 1;
// 
//     /**
//      * @param tag the field tag that has not been found
//      * @param fixMessage the FIX message that does not contain the tag
//      * @return an instance of FixException for a field-not-found case.
//      */
//     public static FixException fieldNotFound(int tag, String fixMessage) {
//         return new FixException("Field [" + tag + "] was not found in message: " + fixMessage);
//     }
// 
//     /**
//      * @param message the exception message
//      * @param cause the exception cause
//      */
//     public FixException(final String message, final Throwable cause) {
//         super(message, cause);
//     }
// 
//     /**
//      * @param cause the exception cause
//      */
//     public FixException(final Throwable cause) {
//         super(cause.getMessage(), cause);
//     }
// 
//     /**
//      * @param message the exception message
//      */
//     public FixException(final String message) {
//         super(message);
//     }
// }
// 
// Path: fixb/src/main/java/org/fixb/FixFieldExtractor.java
// public interface FixFieldExtractor<M> {
// 
//     /**
//      * Reads a tag of the FIX field identified by the given tag. If optional is true then in case of not found field
//      * null will be returned, otherwise should throw a FixException.
//      *
//      * @param fixMessage a FIX message object
//      * @param type       a type to return
//      * @param tag        a FIX field tag to read the tag from
//      * @param optional   determines whether a not found field should generate an exception
//      * @param <T>        the type of the result
//      * @throws FixException
//      */
//     <T> T getFieldValue(M fixMessage, Class<T> type, int tag, boolean optional);
// 
//     /**
//      * Reads all repeating groups from the given FIX message identified by the given tag. If optional is true then in
//      * case of
//      * non found groups null will be returned, otherwise should throw a FixException.
//      *
//      * @param fixMessage  the FIX message object
//      * @param type        the collection type to return
//      * @param groupTag    the FIX group tag to read from
//      * @param elementType type of the resulting collection elements (has the same meaning as the type parameter in
//      *                    getFieldValue)
//      * @param elementTag  the group delimiter tag (or the tag of a single element)
//      * @param optional    determines whether a not found group should generate an exception
//      * @param <T>         type or the resulting collection elements
//      */
//     <T, C extends Collection<T>> C getGroups(M fixMessage,
//                                              Class<C> type,
//                                              int groupTag,
//                                              Class<T> elementType,
//                                              int elementTag,
//                                              boolean optional);
// 
//     /**
//      * Reads all repeating block groups from the given FIX message identified by the given tag. If optional is true
//      * then in case of
//      * non found groups null will be returned, otherwise should throw a FixException.
//      *
//      * @param fixMessage    the FIX message object
//      * @param type          the collection type to return
//      * @param groupTag      the FIX group tag to read from
//      * @param componentMeta the FIX mapping metadata for a single repeating group
//      * @param optional      determines whether a not found group should generate an exception
//      * @param <T>           type or the resulting collection elements
//      */
//     <T, C extends Collection<T>> C getGroups(M fixMessage,
//                                              Class<C> type,
//                                              int groupTag,
//                                              FixBlockMeta<T> componentMeta,
//                                              boolean optional);
// }


import org.fixb.FixException;
import org.fixb.FixFieldExtractor;
import org.fixb.meta.*;
import org.joda.time.*;
import java.math.BigDecimal;
import java.util.*;
            if (f instanceof FixConstantFieldMeta) continue;

            final Object fieldValue;
            if (f.isGroup()) {
                final FixGroupMeta groupMeta = (FixGroupMeta) f;
                fieldValue = groupMeta.isSimple() ?
                        getGroups(cursor,
                                (Class<Collection<Object>>) groupMeta.getType(),
                                groupMeta.getTag(),
                                (Class<Object>) groupMeta.getComponentType(),
                                groupMeta.getComponentTag(),
                                groupMeta.isOptional()) :
                        getGroups(cursor,
                                (Class<Collection<Object>>) groupMeta.getType(),
                                groupMeta.getTag(),
                                (FixBlockMeta<Object>) groupMeta.getComponentMeta(),
                                groupMeta.isOptional());
            } else {
                fieldValue = extractFieldValue(cursor, f.getTag(), f.getType(), f.isOptional());
            }
            values.put(f, fieldValue);
        }
        return componentMeta.createModel(values);
    }

    private <T, C extends Collection<T>> C getGroups(FieldCursor cursor, Class<C> type, int groupTag, FixBlockMeta<T> componentMeta, boolean optional) {
        if (!cursor.nextField(groupTag)) {
            if (optional) {
                return CollectionFactory.createCollection(type);
            } else {
// Path: fixb/src/main/java/org/fixb/FixException.java
// public class FixException extends RuntimeException {
//     private static final long serialVersionUID = 1;
// 
//     /**
//      * @param tag the field tag that has not been found
//      * @param fixMessage the FIX message that does not contain the tag
//      * @return an instance of FixException for a field-not-found case.
//      */
//     public static FixException fieldNotFound(int tag, String fixMessage) {
//         return new FixException("Field [" + tag + "] was not found in message: " + fixMessage);
//     }
// 
//     /**
//      * @param message the exception message
//      * @param cause the exception cause
//      */
//     public FixException(final String message, final Throwable cause) {
//         super(message, cause);
//     }
// 
//     /**
//      * @param cause the exception cause
//      */
//     public FixException(final Throwable cause) {
//         super(cause.getMessage(), cause);
//     }
// 
//     /**
//      * @param message the exception message
//      */
//     public FixException(final String message) {
//         super(message);
//     }
// }
// 
// Path: fixb/src/main/java/org/fixb/FixFieldExtractor.java
// public interface FixFieldExtractor<M> {
// 
//     /**
//      * Reads a tag of the FIX field identified by the given tag. If optional is true then in case of not found field
//      * null will be returned, otherwise should throw a FixException.
//      *
//      * @param fixMessage a FIX message object
//      * @param type       a type to return
//      * @param tag        a FIX field tag to read the tag from
//      * @param optional   determines whether a not found field should generate an exception
//      * @param <T>        the type of the result
//      * @throws FixException
//      */
//     <T> T getFieldValue(M fixMessage, Class<T> type, int tag, boolean optional);
// 
//     /**
//      * Reads all repeating groups from the given FIX message identified by the given tag. If optional is true then in
//      * case of
//      * non found groups null will be returned, otherwise should throw a FixException.
//      *
//      * @param fixMessage  the FIX message object
//      * @param type        the collection type to return
//      * @param groupTag    the FIX group tag to read from
//      * @param elementType type of the resulting collection elements (has the same meaning as the type parameter in
//      *                    getFieldValue)
//      * @param elementTag  the group delimiter tag (or the tag of a single element)
//      * @param optional    determines whether a not found group should generate an exception
//      * @param <T>         type or the resulting collection elements
//      */
//     <T, C extends Collection<T>> C getGroups(M fixMessage,
//                                              Class<C> type,
//                                              int groupTag,
//                                              Class<T> elementType,
//                                              int elementTag,
//                                              boolean optional);
// 
//     /**
//      * Reads all repeating block groups from the given FIX message identified by the given tag. If optional is true
//      * then in case of
//      * non found groups null will be returned, otherwise should throw a FixException.
//      *
//      * @param fixMessage    the FIX message object
//      * @param type          the collection type to return
//      * @param groupTag      the FIX group tag to read from
//      * @param componentMeta the FIX mapping metadata for a single repeating group
//      * @param optional      determines whether a not found group should generate an exception
//      * @param <T>           type or the resulting collection elements
//      */
//     <T, C extends Collection<T>> C getGroups(M fixMessage,
//                                              Class<C> type,
//                                              int groupTag,
//                                              FixBlockMeta<T> componentMeta,
//                                              boolean optional);
// }


// Path: fixb/src/main/java/org/fixb/impl/NativeFixFieldExtractor.java
import org.fixb.FixException;
import org.fixb.FixFieldExtractor;
import org.fixb.meta.*;
import org.joda.time.*;
import java.math.BigDecimal;
import java.util.*;

            if (f instanceof FixConstantFieldMeta) continue;

            final Object fieldValue;
            if (f.isGroup()) {
                final FixGroupMeta groupMeta = (FixGroupMeta) f;
                fieldValue = groupMeta.isSimple() ?
                        getGroups(cursor,
                                (Class<Collection<Object>>) groupMeta.getType(),
                                groupMeta.getTag(),
                                (Class<Object>) groupMeta.getComponentType(),
                                groupMeta.getComponentTag(),
                                groupMeta.isOptional()) :
                        getGroups(cursor,
                                (Class<Collection<Object>>) groupMeta.getType(),
                                groupMeta.getTag(),
                                (FixBlockMeta<Object>) groupMeta.getComponentMeta(),
                                groupMeta.isOptional());
            } else {
                fieldValue = extractFieldValue(cursor, f.getTag(), f.getType(), f.isOptional());
            }
            values.put(f, fieldValue);
        }
        return componentMeta.createModel(values);
    }

    private <T, C extends Collection<T>> C getGroups(FieldCursor cursor, Class<C> type, int groupTag, FixBlockMeta<T> componentMeta, boolean optional) {
        if (!cursor.nextField(groupTag)) {
            if (optional) {
                return CollectionFactory.createCollection(type);
            } else {
                throw FixException.fieldNotFound(groupTag, cursor.fixMessage);