• Home
• io.fixprotocol.orchestra
• repository-quickfix
• 1.6.1
• source code
• CodeGeneratorJ.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

/*
 * Copyright 2017-2020 FIX Protocol Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 *
 */
package io.fixprotocol.orchestra.quickfix;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
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._2020.orchestra.repository.CodeSetType;
import io.fixprotocol._2020.orchestra.repository.CodeType;
import io.fixprotocol._2020.orchestra.repository.ComponentRefType;
import io.fixprotocol._2020.orchestra.repository.ComponentType;
import io.fixprotocol._2020.orchestra.repository.FieldRefType;
import io.fixprotocol._2020.orchestra.repository.FieldType;
import io.fixprotocol._2020.orchestra.repository.GroupRefType;
import io.fixprotocol._2020.orchestra.repository.GroupType;
import io.fixprotocol._2020.orchestra.repository.MessageType;
import io.fixprotocol._2020.orchestra.repository.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 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".
   * @throws IOException an IO error occurred
   * @throws FileNotFoundException the Orchestra file is not found
   */
  public static void main(String[] args) throws IOException {
    final CodeGeneratorJ generator = new CodeGeneratorJ();
    if (args.length >= 1) {
      final File inputFile = new File(args[0]);
      File outputDir;
      if (args.length >= 2) {
        outputDir = new File(args[1]);
      } else {
        outputDir = new File("target/generated-sources");
      }
      try (FileInputStream inputStream = new FileInputStream(inputFile)) {
        generator.generate(inputStream, 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(InputStream inputFile, File outputDir) {
    try {
      final Repository repository = unmarshal(inputFile);
      final List codeSetList = repository.getCodeSets().getCodeSet();
      for (final CodeSetType codeSet : codeSetList) {
        codeSets.put(codeSet.getName(), codeSet);
      }

      final List fieldList = repository.getFields().getField();
      final File fileDir = getPackagePath(outputDir, FIELD_PACKAGE);
      fileDir.mkdirs();
      for (final FieldType fieldType : fieldList) {
        fields.put(fieldType.getId().intValue(), fieldType);
        generateField(outputDir, fieldType, FIELD_PACKAGE);
      }

      String version = repository.getVersion();
      // Split off EP portion of version
      final String[] parts = version.split("_");
      if (parts.length > 0) {
        version = parts[0];
      }
      final String versionPath = version.replaceAll("[\\.]", "").toLowerCase();
      final String componentPackage = getPackage("quickfix", versionPath, "component");
      final File componentDir = getPackagePath(outputDir, componentPackage);
      componentDir.mkdirs();
      final List componentList = repository.getComponents().getComponent();
      for (final ComponentType component : componentList) {
        components.put(component.getId().intValue(), component);
      }
      final List groupList = repository.getGroups().getGroup();
      for (final GroupType group : groupList) {
        groups.put(group.getId().intValue(), group);
      }

      for (final GroupType group : groupList) {
        generateGroup(outputDir, group, componentPackage);
      }
      for (final ComponentType component : componentList) {
        generateComponent(outputDir, component, componentPackage);
      }
      final String messagePackage = getPackage("quickfix", versionPath);
      final File messageDir = getPackagePath(outputDir, messagePackage);
      messageDir.mkdirs();
      final List messageList = repository.getMessages().getMessage();
      for (final 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 {
    final String name = toTitleCase(componentType.getName());
    final 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, "");

      final List componentFields = new ArrayList<>();
      final List