QFJ-981 / QFJ-982 Remove settings from DataDictionary class

quickfixj-core/src/main/java/quickfix/DataDictionary.java

@@ -68,11 +68,6 @@ public class DataDictionary {
     private static final int USER_DEFINED_TAG_MIN = 5000;
     private static final String NO = "N";
     private boolean hasVersion = false;
-    private boolean checkFieldsOutOfOrder = true;
-    private boolean checkFieldsHaveValues = true;
-    private boolean checkUserDefinedFields = true;
-    private boolean checkUnorderedGroupFields = true;
-    private boolean allowUnknownMessageFields = false;
     private String beginString;
     private final Map<String, Set<Integer>> messageFields = new HashMap<>();
     private final Map<String, Set<Integer>> requiredFields = new HashMap<>();
@@ -429,86 +424,6 @@ private boolean isMultipleValueStringField(int field) {
         return fieldType == FieldType.MULTIPLEVALUESTRING || fieldType == FieldType.MULTIPLESTRINGVALUE;
     }
 
-    /**
-     * Controls whether out of order fields are checked.
-     *
-     * @param flag true = checked, false = not checked
-     */
-    public void setCheckFieldsOutOfOrder(boolean flag) {
-        checkFieldsOutOfOrder = flag;
-    }
-
-    public boolean isCheckFieldsOutOfOrder() {
-        return checkFieldsOutOfOrder;
-    }
-
-    public boolean isCheckUnorderedGroupFields() {
-        return checkUnorderedGroupFields;
-    }
-
-    public boolean isCheckFieldsHaveValues() {
-        return checkFieldsHaveValues;
-    }
-
-    public boolean isCheckUserDefinedFields() {
-        return checkUserDefinedFields;
-    }
-
-    public boolean isAllowUnknownMessageFields() {
-        return allowUnknownMessageFields;
-    }
-
-    /**
-     * Controls whether group fields are in the same order
-     *
-     * @param flag true = checked, false = not checked
-     */
-    public void setCheckUnorderedGroupFields(boolean flag) {
-        checkUnorderedGroupFields = flag;
-        for (Map<Integer, GroupInfo> gm : groups.values()) {
-            for (GroupInfo gi : gm.values()) {
-                gi.getDataDictionary().setCheckUnorderedGroupFields(flag);
-            }
-        }
-    }
-
-    /**
-     * Controls whether empty field values are checked.
-     *
-     * @param flag true = checked, false = not checked
-     */
-    public void setCheckFieldsHaveValues(boolean flag) {
-        checkFieldsHaveValues = flag;
-        for (Map<Integer, GroupInfo> gm : groups.values()) {
-            for (GroupInfo gi : gm.values()) {
-                gi.getDataDictionary().setCheckFieldsHaveValues(flag);
-            }
-        }
-    }
-
-    /**
-     * Controls whether user defined fields are checked.
-     *
-     * @param flag true = checked, false = not checked
-     */
-    public void setCheckUserDefinedFields(boolean flag) {
-        checkUserDefinedFields = flag;
-        for (Map<Integer, GroupInfo> gm : groups.values()) {
-            for (GroupInfo gi : gm.values()) {
-                gi.getDataDictionary().setCheckUserDefinedFields(flag);
-            }
-        }
-    }
-
-    public void setAllowUnknownMessageFields(boolean allowUnknownFields) {
-        allowUnknownMessageFields = allowUnknownFields;
-        for (Map<Integer, GroupInfo> gm : groups.values()) {
-            for (GroupInfo gi : gm.values()) {
-                gi.getDataDictionary().setAllowUnknownMessageFields(allowUnknownFields);
-            }
-        }
-    }
-
     private void copyFrom(DataDictionary rhs) {
         hasVersion = rhs.hasVersion;
         beginString = rhs.beginString;
@@ -524,13 +439,6 @@ private void copyFrom(DataDictionary rhs) {
         copyMap(valueNames, rhs.valueNames);
         copyGroups(groups, rhs.groups);
         copyMap(components, rhs.components);
-
-        setCheckFieldsOutOfOrder(rhs.checkFieldsOutOfOrder);
-        setCheckFieldsHaveValues(rhs.checkFieldsHaveValues);
-        setCheckUserDefinedFields(rhs.checkUserDefinedFields);
-        setCheckUnorderedGroupFields(rhs.checkUnorderedGroupFields);
-        setAllowUnknownMessageFields(rhs.allowUnknownMessageFields);
-
         calculateOrderedFields();
     }
 
@@ -584,9 +492,9 @@ private static <V> void copyCollection(Collection<V> lhs, Collection<V> rhs) {
      * @throws FieldNotFound if a field cannot be found
      * @throws IncorrectDataFormat if a field value has a wrong data type
      */
-    public void validate(Message message) throws IncorrectTagValue, FieldNotFound,
+    public void validate(Message message, ValidationSettings settings) throws IncorrectTagValue, FieldNotFound,
             IncorrectDataFormat {
-        validate(message, false);
+        validate(message, false, settings);
     }
 
     /**
@@ -598,13 +506,13 @@ public void validate(Message message) throws IncorrectTagValue, FieldNotFound,
      * @throws FieldNotFound if a field cannot be found
      * @throws IncorrectDataFormat if a field value has a wrong data type
      */
-    public void validate(Message message, boolean bodyOnly) throws IncorrectTagValue,
+    public void validate(Message message, boolean bodyOnly, ValidationSettings settings) throws IncorrectTagValue,
             FieldNotFound, IncorrectDataFormat {
-        validate(message, bodyOnly ? null : this, this);
+        validate(message, bodyOnly ? null : this, this, settings);
     }
 
     static void validate(Message message, DataDictionary sessionDataDictionary,
-            DataDictionary applicationDataDictionary) throws IncorrectTagValue, FieldNotFound,
+            DataDictionary applicationDataDictionary, ValidationSettings settings) throws IncorrectTagValue, FieldNotFound,
             IncorrectDataFormat {
         final boolean bodyOnly = sessionDataDictionary == null;
 
@@ -629,39 +537,39 @@ static void validate(Message message, DataDictionary sessionDataDictionary,
         }
 
         if (!bodyOnly) {
-            sessionDataDictionary.iterate(message.getHeader(), HEADER_ID, sessionDataDictionary);
-            sessionDataDictionary.iterate(message.getTrailer(), TRAILER_ID, sessionDataDictionary);
+            sessionDataDictionary.iterate(settings, message.getHeader(), HEADER_ID, sessionDataDictionary);
+            sessionDataDictionary.iterate(settings, message.getTrailer(), TRAILER_ID, sessionDataDictionary);
         }
 
-        applicationDataDictionary.iterate(message, msgType, applicationDataDictionary);
+        applicationDataDictionary.iterate(settings, message, msgType, applicationDataDictionary);
     }
 
     private static boolean isVersionSpecified(DataDictionary dd) {
         return dd != null && dd.hasVersion;
     }
 
-    private void iterate(FieldMap map, String msgType, DataDictionary dd) throws IncorrectTagValue,
+    private void iterate(ValidationSettings settings, FieldMap map, String msgType, DataDictionary dd) throws IncorrectTagValue,
             IncorrectDataFormat {
         final Iterator<Field<?>> iterator = map.iterator();
         while (iterator.hasNext()) {
             final StringField field = (StringField) iterator.next();
 
-            checkHasValue(field);
+            checkHasValue(settings, field);
 
             if (hasVersion) {
-                checkValidFormat(field);
+                checkValidFormat(settings, field);
                 checkValue(field);
             }
 
             if (beginString != null) {
-                dd.checkField(field, msgType, map instanceof Message);
+                dd.checkField(settings, field, msgType, map instanceof Message);
                 dd.checkGroupCount(field, map, msgType);
             }
         }
 
         for (final List<Group> groups : map.getGroups().values()) {
             for (final Group group : groups) {
-                iterate(group, msgType, dd.getGroup(msgType, group.getFieldTag())
+                iterate(settings, group, msgType, dd.getGroup(msgType, group.getFieldTag())
                         .getDataDictionary());
             }
         }
@@ -682,10 +590,10 @@ void checkValidTagNumber(Field<?> field) {
     }
 
     /** Check if field tag is defined for message or group **/
-    void checkField(Field<?> field, String msgType, boolean message) {
+    void checkField(ValidationSettings settings, Field<?> field, String msgType, boolean message) {
         // use different validation for groups and messages
         boolean messageField = message ? isMsgField(msgType, field.getField()) : fields.contains(field.getField());
-        boolean fail = checkFieldFailure(field.getField(), messageField);
+        boolean fail = checkFieldFailure(settings, field.getField(), messageField);
 
         if (fail) {
             if (fields.contains(field.getField())) {
@@ -696,22 +604,22 @@ void checkField(Field<?> field, String msgType, boolean message) {
         }
     }
 
-    boolean checkFieldFailure(int field, boolean messageField) {
+    boolean checkFieldFailure(ValidationSettings settings, int field, boolean messageField) {
         boolean fail;
         if (field < USER_DEFINED_TAG_MIN) {
-            fail = !messageField && !allowUnknownMessageFields;
+            fail = !messageField && !settings.allowUnknownMessageFields;
         } else {
-            fail = !messageField && checkUserDefinedFields;
+            fail = !messageField && settings.checkUserDefinedFields;
         }
         return fail;
     }
 
-    private void checkValidFormat(StringField field) throws IncorrectDataFormat {
+    private void checkValidFormat(ValidationSettings settings, StringField field) throws IncorrectDataFormat {
         FieldType fieldType = getFieldType(field.getTag());
         if (fieldType == null) {
             return;
         }
-        if (!checkFieldsHaveValues && field.getValue().length() == 0) {
+        if (!settings.checkFieldsHaveValues && field.getValue().length() == 0) {
             return;
         }
         try {
@@ -773,8 +681,8 @@ private void checkValue(StringField field) throws IncorrectTagValue {
     }
 
     /** Check if a field has a value. **/
-    private void checkHasValue(StringField field) {
-        if (checkFieldsHaveValues && field.getValue().length() == 0) {
+    private void checkHasValue(ValidationSettings settings, StringField field) {
+        if (settings.checkFieldsHaveValues && field.getValue().length() == 0) {
             throw new FieldException(SessionRejectReason.TAG_SPECIFIED_WITHOUT_A_VALUE,
                     field.getField());
         }

quickfixj-core/src/main/java/quickfix/DefaultSessionFactory.java

@@ -152,6 +152,7 @@ public Session create(SessionID sessionID, SessionSettings settings) throws Conf
                     processPreFixtDataDictionary(sessionID, settings, dataDictionaryProvider);
                 }
             }
+            ValidationSettings validationSettings = createValidationSettings(sessionID, settings);
 
             int heartbeatInterval = 0;
             if (connectionType.equals(SessionFactory.INITIATOR_CONNECTION_TYPE)) {
@@ -215,7 +216,7 @@ public Session create(SessionID sessionID, SessionSettings settings) throws Conf
             final SessionSchedule sessionSchedule = sessionScheduleFactory.create(sessionID, settings);
 
             final Session session = new Session(application, messageStoreFactory, sessionID,
-                    dataDictionaryProvider, sessionSchedule, logFactory,
+                    dataDictionaryProvider, validationSettings, sessionSchedule, logFactory,
                     messageFactory, heartbeatInterval, checkLatency, maxLatency, timestampPrecision,
                     resetOnLogon, resetOnLogout, resetOnDisconnect, refreshAtLogon, checkCompID,
                     redundantResentRequestAllowed, persistMessages, useClosedIntervalForResend,
@@ -259,34 +260,38 @@ private void processPreFixtDataDictionary(SessionID sessionID, SessionSettings s
     private DataDictionary createDataDictionary(SessionID sessionID, SessionSettings settings,
             String settingsKey, String beginString) throws ConfigError, FieldConvertError {
         final String path = getDictionaryPath(sessionID, settings, settingsKey, beginString);
-        final DataDictionary dataDictionary = getDataDictionary(path);
+        return getDataDictionary(path);
+    }
+
+    private ValidationSettings createValidationSettings(SessionID sessionID, SessionSettings settings) throws FieldConvertError, ConfigError {
+        ValidationSettings validationSettings = new ValidationSettings();
 
         if (settings.isSetting(sessionID, Session.SETTING_VALIDATE_FIELDS_OUT_OF_ORDER)) {
-            dataDictionary.setCheckFieldsOutOfOrder(settings.getBool(sessionID,
+            validationSettings.setCheckFieldsOutOfOrder(settings.getBool(sessionID,
                     Session.SETTING_VALIDATE_FIELDS_OUT_OF_ORDER));
         }
 
         if (settings.isSetting(sessionID, Session.SETTING_VALIDATE_FIELDS_HAVE_VALUES)) {
-            dataDictionary.setCheckFieldsHaveValues(settings.getBool(sessionID,
+            validationSettings.setCheckFieldsHaveValues(settings.getBool(sessionID,
                     Session.SETTING_VALIDATE_FIELDS_HAVE_VALUES));
         }
 
         if (settings.isSetting(sessionID, Session.SETTING_VALIDATE_UNORDERED_GROUP_FIELDS)) {
-            dataDictionary.setCheckUnorderedGroupFields(settings.getBool(sessionID,
+            validationSettings.setCheckUnorderedGroupFields(settings.getBool(sessionID,
                     Session.SETTING_VALIDATE_UNORDERED_GROUP_FIELDS));
         }
 
         if (settings.isSetting(sessionID, Session.SETTING_VALIDATE_USER_DEFINED_FIELDS)) {
-            dataDictionary.setCheckUserDefinedFields(settings.getBool(sessionID,
+            validationSettings.setCheckUserDefinedFields(settings.getBool(sessionID,
                     Session.SETTING_VALIDATE_USER_DEFINED_FIELDS));
         }
 
         if (settings.isSetting(sessionID, Session.SETTING_ALLOW_UNKNOWN_MSG_FIELDS)) {
-            dataDictionary.setAllowUnknownMessageFields(settings.getBool(sessionID,
+            validationSettings.setAllowUnknownMessageFields(settings.getBool(sessionID,
                     Session.SETTING_ALLOW_UNKNOWN_MSG_FIELDS));
         }
 
-        return dataDictionary;
+        return validationSettings;
     }
 
     private void processFixtDataDictionaries(SessionID sessionID, SessionSettings settings,