io.fixprotocol.orchestra.quickfix.CodeGeneratorJ Maven / Gradle / Ivy

Go to download
package io.fixprotocol.orchestra.quickfix;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;

import io.fixprotocol._2016.fixrepository.CodeSetType;
import io.fixprotocol._2016.fixrepository.CodeSets;
import io.fixprotocol._2016.fixrepository.CodeType;
import io.fixprotocol._2016.fixrepository.ComponentRefType;
import io.fixprotocol._2016.fixrepository.ComponentType;
import io.fixprotocol._2016.fixrepository.FieldRefType;
import io.fixprotocol._2016.fixrepository.FieldType;
import io.fixprotocol._2016.fixrepository.GroupRefType;
import io.fixprotocol._2016.fixrepository.GroupType;
import io.fixprotocol._2016.fixrepository.MessageType;
import io.fixprotocol._2016.fixrepository.Protocol;
import io.fixprotocol._2016.fixrepository.Repository;

/**
 * Generates message classes for QuickFIX/J from a FIX Orchestra file
 * 
 * Unlike the QuickFIX/J code generator, this utility works directly from a FIX Orchestra or FIX
 * Repository 2016 Edition file rather than from a QuickFIX data dictionary file.
 * 

 * For now, message validation in QuickFIX/J still requires a data dictionary file, but in future
 * versions, validations may be delegated to additional generated code that takes advantage to
 * conditional logic supported by Orchestra. For example, a validator may invoke an evaluation of an
 * expression for a conditionally required field.
 * 
 * @author Don Mendelson
 *
 */
public class CodeGeneratorJ {

  private static final List DATE_TYPES =
      Arrays.asList("UTCTimestamp", "UTCTimeOnly", "UTCDateOnly", "LocalMktDate", "LocalMktTime");

  private static final String FIELD_PACKAGE = "quickfix.field";

  private static final long SERIALIZATION_VERSION = 552892318L;

  private static final int SPACES_PER_LEVEL = 2;

  /**
   * Runs a CodeGeneratorJ with command line arguments
   * 
   * @param args command line arguments. The first argument is the name of a FIX Orchestra file. An
   *        optional second argument is the target directory for generated code. It defaults to
   *        "target/generated-sources".
   */
  public static void main(String[] args) {
    CodeGeneratorJ generator = new CodeGeneratorJ();
    if (args.length >= 1) {
      File inputFile = new File(args[0]);
      File outputDir;
      if (args.length >= 2) {
        outputDir = new File(args[1]);
      } else {
        outputDir = new File("target/generated-sources");
      }
      generator.generate(inputFile, outputDir);
    } else {
      generator.usage();
    }
  }

  private final Map codeSets = new HashMap<>();
  private final Map components = new HashMap<>();
  private final Map fields = new HashMap<>();
  private final Map groups = new HashMap<>();

  public void generate(File inputFile, File outputDir) {
    try {
      final Repository repository = unmarshal(inputFile);
      final List codeSetsList = repository.getCodeSets();
      for (CodeSets codeSetsCollection : codeSetsList) {
        final List codeSetList = codeSetsCollection.getCodeSet();
        for (CodeSetType codeSet : codeSetList) {
          codeSets.put(codeSet.getName(), codeSet);
        }
      }

      final List fieldList = repository.getFields().getField();
      final File fileDir = getPackagePath(outputDir, FIELD_PACKAGE);
      fileDir.mkdirs();
      for (FieldType fieldType : fieldList) {
        fields.put(fieldType.getId().intValue(), fieldType);
        generateField(outputDir, fieldType, FIELD_PACKAGE);
      }
      final List protocols = repository.getProtocol();
      for (Protocol protocol : protocols) {
        String version = protocol.getVersion();
        // Split off EP portion of version
        String[] parts = version.split("_");
        if (parts.length > 0) {
          version = parts[0];
        }
        String versionPath = version.replaceAll("[\\.]", "").toLowerCase();
        final String componentPackage = getPackage("quickfix", versionPath, "component");
        final File componentDir = getPackagePath(outputDir, componentPackage);
        componentDir.mkdirs();
        final List componentList = protocol.getComponents().getComponentOrGroup();
        for (ComponentType component : componentList) {
          if (component instanceof GroupType) {
            groups.put(component.getId().intValue(), (GroupType) component);
          } else {
            components.put(component.getId().intValue(), component);
          }
        }
        for (ComponentType component : componentList) {
          if (component instanceof GroupType) {
            generateGroup(outputDir, (GroupType) component, componentPackage);
          } else if (protocol.isHasComponents()) {
            generateComponent(outputDir, component, componentPackage);
          }
        }
        final String messagePackage = getPackage("quickfix", versionPath);
        final File messageDir = getPackagePath(outputDir, messagePackage);
        messageDir.mkdirs();
        final List messageList = protocol.getMessages().getMessage();
        for (MessageType message : messageList) {
          generateMessage(outputDir, message, messagePackage, componentPackage);
        }
        generateMessageBaseClass(outputDir, version, messagePackage);
        generateMessageFactory(outputDir, messagePackage, messageList);
        generateMessageCracker(outputDir, messagePackage, messageList);
      }
    } catch (JAXBException | IOException e) {
      e.printStackTrace();
    }
  }

  private void generateComponent(File outputDir, ComponentType componentType, String packageName)
      throws IOException {
    String name = toTitleCase(componentType.getName());
    File file = getClassFilePath(outputDir, packageName, name);
    try (FileWriter writer = new FileWriter(file)) {
      writeFileHeader(writer);
      writePackage(writer, packageName);
      writeImport(writer, "quickfix.FieldNotFound");
      writeImport(writer, "quickfix.Group");

      writeClassDeclaration(writer, name, "quickfix.MessageComponent");
      writeSerializationVersion(writer, SERIALIZATION_VERSION);
      writeMsgType(writer, "");

      List componentFields = new ArrayList<>();
      List